home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / wgdb-42.lha / wgdb-4.2 / bfd / ieee.c < prev    next >
C/C++ Source or Header  |  1992-09-11  |  71KB  |  2,950 lines
  1. /* bfd back-end for ieee-695 objects.
  2.    Copyright (C) 1990-1991 Free Software Foundation, Inc.
  3.    Written by Steve Chamberlain of Cygnus Support.
  4.  
  5. This file is part of BFD, the Binary File Descriptor library.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* IEEE 695 format is a stream of records, which we parse using a simple one-
  22.    token (which is one byte in this lexicon) lookahead recursive decent
  23.    parser.  */
  24.  
  25. #include "bfd.h"
  26. #include "sysdep.h"
  27. #include "libbfd.h"
  28. #include "ieee.h"
  29. #include "libieee.h"
  30.  
  31. /* Functions for writing to ieee files in the strange way that the
  32.    standard requires. */
  33.  
  34. static void
  35. DEFUN(ieee_write_byte,(abfd, byte),
  36.       bfd *abfd AND
  37.       bfd_byte byte)
  38. {
  39.   bfd_write((PTR)&byte, 1, 1, abfd);
  40. }
  41.  
  42.  
  43. static void
  44. DEFUN(ieee_write_twobyte,(abfd, twobyte),
  45.       bfd *abfd AND
  46.       int twobyte)
  47. {
  48.   bfd_byte b[2];
  49.   b[1] = twobyte & 0xff;
  50.   b[0] = twobyte >> 8;
  51.   bfd_write((PTR)&b[0], 1, 2, abfd);
  52. }
  53.  
  54.  
  55.  
  56. static void
  57. DEFUN(ieee_write_2bytes,(abfd, bytes),
  58.       bfd *abfd AND
  59.       int bytes)
  60. {
  61.   bfd_byte buffer[2];
  62.   buffer[0] = bytes >> 8;
  63.   buffer[1] = bytes & 0xff;
  64.  
  65.   bfd_write((PTR)buffer, 1, 2, abfd);
  66. }
  67.  
  68. static void
  69. DEFUN(ieee_write_int,(abfd, value),
  70.       bfd *abfd AND
  71.       bfd_vma value)
  72. {
  73.   if (((unsigned)value) <= 127) {
  74.     ieee_write_byte(abfd, value);
  75.   }
  76.   else {
  77.     unsigned int length;
  78.     /* How many significant bytes ? */
  79.     /* FIXME FOR LONGER INTS */
  80.     if (value & 0xff000000) {
  81.       length = 4;
  82.     }
  83.     else if (value & 0x00ff0000) {
  84.       length  = 3;
  85.     }
  86.     else if (value & 0x0000ff00) {
  87.       length = 2;
  88.     }
  89.     else length = 1;
  90.  
  91.     ieee_write_byte(abfd, (int)ieee_number_repeat_start_enum + length);
  92.     switch (length) {
  93.     case 4:
  94.       ieee_write_byte(abfd, value >> 24);
  95.     case 3:
  96.       ieee_write_byte(abfd, value >> 16);
  97.     case 2:
  98.       ieee_write_byte(abfd, value >> 8);
  99.     case 1:
  100.       ieee_write_byte(abfd, value);
  101.     }
  102.   }
  103. }
  104.  
  105. static void
  106. DEFUN(ieee_write_id,(abfd, id),
  107.       bfd *abfd AND
  108.       CONST char *id)
  109. {
  110.   size_t length = strlen(id);
  111.   if (length >= 0 && length <= 127) {
  112.     ieee_write_byte(abfd, length);
  113.   }
  114.   else if (length < 255) {
  115.     ieee_write_byte(abfd, ieee_extension_length_1_enum);
  116.     ieee_write_byte(abfd, length);
  117.   }
  118.   else if (length < 65535) {
  119.     ieee_write_byte(abfd, ieee_extension_length_2_enum);
  120.     ieee_write_byte(abfd, length >> 8);
  121.     ieee_write_byte(abfd, length & 0xff);  
  122.   }
  123.   else {
  124.     BFD_FAIL();
  125.   }
  126.   bfd_write((PTR)id, 1, length, abfd);
  127. }
  128. /***************************************************************************
  129. Functions for reading from ieee files in the strange way that the
  130. standard requires:
  131. */
  132.  
  133.  
  134. #define this_byte(ieee) *((ieee)->input_p)
  135. #define next_byte(ieee) ((ieee)->input_p++)
  136. #define this_byte_and_next(ieee) (*((ieee)->input_p++))
  137.  
  138.  
  139. static unsigned short 
  140. DEFUN(read_2bytes,(ieee),
  141.    common_header_type *ieee)
  142. {
  143.   unsigned  char c1 = this_byte_and_next(ieee);
  144.   unsigned  char c2 = this_byte_and_next(ieee);
  145.   return (c1<<8 ) | c2;
  146.  
  147. }
  148.  
  149. static void
  150. DEFUN(bfd_get_string,(ieee, string, length),
  151.     common_header_type *ieee AND
  152.       char *string AND
  153.       size_t length)
  154. {
  155.   size_t i;
  156.   for (i= 0; i < length; i++) {
  157.     string[i] = this_byte_and_next(ieee);
  158.   }
  159. }
  160.  
  161. static char *
  162. DEFUN(read_id,(ieee),
  163.   common_header_type *ieee)
  164. {
  165.   size_t length;
  166.   char *string;
  167.   length = this_byte_and_next(ieee);
  168.   if (length >= 0x00 && length <= 0x7f) {
  169.     /* Simple string of length 0 to 127 */
  170.   }
  171.   else if (length == 0xde) {
  172.     /* Length is next byte, allowing 0..255 */
  173.     length = this_byte_and_next(ieee);
  174.   }
  175.   else if (length == 0xdf) {
  176.     /* Length is next two bytes, allowing 0..65535 */
  177.     length = this_byte_and_next(ieee) ;
  178.     length = (length * 256) + this_byte_and_next(ieee);
  179.   }
  180.   /* Buy memory and read string */
  181.   string = bfd_alloc(ieee->abfd, length+1);
  182.   bfd_get_string(ieee, string, length);
  183.   string[length] = 0;
  184.   return string;
  185. }
  186.  
  187. static void
  188. DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index),
  189.       bfd*abfd AND
  190.       bfd_vma value AND
  191.       asection *section AND
  192.       asymbol *symbol AND
  193.       boolean pcrel AND
  194.     unsigned int index)
  195. {
  196.   unsigned int plus_count = 0;
  197.   if (value != 0)
  198.     ieee_write_int(abfd, value);
  199.  
  200.   if (section != (asection *)NULL) {
  201.     plus_count++;
  202.     ieee_write_byte(abfd, ieee_variable_R_enum);
  203.     ieee_write_byte(abfd, section->index  +IEEE_SECTION_NUMBER_BASE);
  204.   }
  205.  
  206.  
  207.  
  208.   if (symbol != (asymbol *)NULL) {
  209.     plus_count++;
  210.     if ((symbol->flags & BSF_UNDEFINED ) ||
  211.     (symbol->flags & BSF_FORT_COMM)) {
  212.       ieee_write_byte(abfd, ieee_variable_X_enum);
  213.       ieee_write_int(abfd, symbol->value);
  214.     }
  215.     else if (symbol->flags & BSF_GLOBAL) {
  216.       ieee_write_byte(abfd, ieee_variable_I_enum);
  217.       ieee_write_int(abfd, symbol->value);
  218.     }
  219.     else if (symbol->flags & BSF_LOCAL) {
  220.       /* This is a reference to a defined local symbol, 
  221.      We can easily do a local as a section+offset */
  222.       if (symbol->section != (asection *)NULL) {
  223.     /* If this symbol is not absolute, add the base of it */
  224.     ieee_write_byte(abfd, ieee_variable_R_enum); /* or L */
  225.     ieee_write_byte(abfd, symbol->section->index +
  226.             IEEE_SECTION_NUMBER_BASE);
  227.     plus_count++;
  228.       }
  229.       
  230.       ieee_write_int(abfd, symbol->value);
  231.     }
  232.     else {
  233.  
  234.       BFD_FAIL();
  235.     }
  236.   }
  237.  
  238.   if(pcrel) {
  239.     /* subtract the pc from here by asking for PC of this section*/
  240.     ieee_write_byte(abfd, ieee_variable_P_enum);
  241.     ieee_write_byte(abfd, index  +IEEE_SECTION_NUMBER_BASE);
  242.     ieee_write_byte(abfd, ieee_function_minus_enum);
  243.   }
  244.  
  245.   if (value != 0){
  246.     while (plus_count > 0) {
  247.       ieee_write_byte(abfd, ieee_function_plus_enum);
  248.       plus_count--;
  249.     }
  250.   }
  251.   else {
  252.     if (!plus_count)
  253.       ieee_write_byte(abfd,0);
  254.   }
  255.  
  256. }
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266. /*****************************************************************************/
  267.  
  268. /*
  269. writes any integer into the buffer supplied and always takes 5 bytes
  270. */
  271. static void
  272. DEFUN(ieee_write_int5,(buffer, value),
  273.       bfd_byte*buffer AND
  274.       bfd_vma value )
  275. {
  276.   buffer[0] = (bfd_byte)ieee_number_repeat_4_enum;
  277.   buffer[1] = (value >> 24 ) & 0xff;
  278.   buffer[2] = (value >> 16 ) & 0xff;
  279.   buffer[3] = (value >> 8 ) & 0xff;
  280.   buffer[4] = (value >> 0 ) & 0xff;
  281. }
  282. static void
  283. DEFUN(ieee_write_int5_out, (abfd, value),
  284.       bfd *abfd AND
  285.       bfd_vma value)
  286. {
  287.   bfd_byte b[5];
  288.   ieee_write_int5(b, value);
  289.   bfd_write((PTR)b,1,5,abfd);
  290. }
  291.  
  292.  
  293. static boolean 
  294. DEFUN(parse_int,(ieee, value_ptr),
  295.       common_header_type  *ieee AND
  296.       bfd_vma *value_ptr)
  297. {
  298.   int value = this_byte(ieee);
  299.   int result;
  300.   if (value >= 0 && value <= 127) {
  301.     *value_ptr = value;
  302.     next_byte(ieee);
  303.     return true;
  304.   } 
  305.   else if (value >= 0x80 && value <= 0x88) {
  306.     unsigned int count = value & 0xf;
  307.     result = 0;
  308.     next_byte(ieee);
  309.     while (count) {
  310.       result =(result << 8) | this_byte_and_next(ieee);
  311.       count--;
  312.     }
  313.     *value_ptr = result;
  314.     return true;
  315.   } 
  316.   return false;
  317. }
  318. static int
  319. DEFUN(parse_i,(ieee, ok),
  320.    common_header_type *ieee AND
  321.       boolean *ok)
  322. {
  323.   bfd_vma x;
  324.   *ok = parse_int(ieee, &x);
  325.   return x;
  326. }
  327.  
  328. static bfd_vma 
  329. DEFUN(must_parse_int,(ieee),
  330.      common_header_type *ieee)
  331. {
  332.   bfd_vma result;
  333.   BFD_ASSERT(parse_int(ieee, &result) == true);
  334.   return result;
  335. }
  336.  
  337. typedef struct 
  338. {
  339.   bfd_vma value;
  340.   asection *section;
  341.   ieee_symbol_index_type symbol;
  342. } ieee_value_type;
  343.  
  344.  
  345. static 
  346. reloc_howto_type abs32_howto 
  347.  = HOWTO(1,0,2,32,false,0,false,true,0,"abs32",true,0xffffffff, 0xffffffff,false);
  348. static
  349. reloc_howto_type abs16_howto 
  350.  = HOWTO(1,0,1,16,false,0,false,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
  351.  
  352. static
  353. reloc_howto_type abs8_howto 
  354.  = HOWTO(1,0,0,8,false,0,false,true,0,"abs8",true,0x000000ff, 0x000000ff,false);
  355.  
  356. static 
  357. reloc_howto_type rel32_howto 
  358.  = HOWTO(1,0,2,32,true,0,false,true,0,"rel32",true,0xffffffff, 0xffffffff,true);
  359. static
  360. reloc_howto_type rel16_howto 
  361.  = HOWTO(1,0,1,16,true,0,false,true,0,"rel16",true,0x0000ffff, 0x0000ffff,true);
  362.  
  363. static
  364. reloc_howto_type rel8_howto 
  365.  = HOWTO(1,0,0,8,true,0,false,true,0,"rel8",true,0x000000ff, 0x000000ff,true);
  366.  
  367.  
  368. static ieee_symbol_index_type NOSYMBOL = {  0, 0};
  369.  
  370.  
  371. static void
  372. DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
  373.       ieee_data_type *ieee AND
  374.       bfd_vma *value AND
  375.       asection **section AND
  376.       ieee_symbol_index_type *symbol AND
  377.       boolean *pcrel AND
  378.       unsigned int *extra)
  379.  
  380. {
  381. #define POS sp[1]
  382. #define TOS sp[0]
  383. #define NOS sp[-1]
  384. #define INC sp++;
  385. #define DEC sp--;
  386.  
  387.   boolean loop = true;
  388.   ieee_value_type stack[10];
  389.  
  390.   /* The stack pointer always points to the next unused location */
  391. #define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC;
  392. #define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value;
  393.   ieee_value_type *sp = stack;
  394.  
  395.   while (loop) {
  396.     switch (this_byte(&(ieee->h))) 
  397.     {
  398.     case ieee_variable_P_enum:
  399.       /* P variable, current program counter for section n */
  400.         {
  401.           int section_n ;
  402.           next_byte(&(ieee->h));
  403.           *pcrel = true;
  404.           section_n  = must_parse_int(&(ieee->h));
  405.           PUSH(NOSYMBOL, 0,
  406.            TOS.value = ieee->section_table[section_n]->vma +
  407.            ieee_per_section(ieee->section_table[section_n])->pc);
  408.           break;
  409.         }
  410.     case ieee_variable_L_enum:
  411.       /* L variable  address of section N */
  412.       next_byte(&(ieee->h));
  413.       PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],0);
  414.       break;
  415.     case ieee_variable_R_enum:
  416.       /* R variable, logical address of section module */
  417.       /* FIXME, this should be different to L */
  418.       next_byte(&(ieee->h));
  419.       PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],0);
  420.       break;
  421.     case ieee_variable_S_enum:
  422.       /* S variable, size in MAUS of section module */
  423.       next_byte(&(ieee->h));
  424.       PUSH(NOSYMBOL,
  425.            0,
  426.            ieee->section_table[must_parse_int(&(ieee->h))]->size);
  427.       break;
  428.       case ieee_variable_I_enum:
  429.     case ieee_variable_X_enum:
  430.       /* Push the address of external variable n */
  431.         {
  432.           ieee_symbol_index_type sy;
  433.           next_byte(&(ieee->h));
  434.           sy.index  = (int)(must_parse_int(&(ieee->h))) ;
  435.           sy.letter = 'X';
  436.  
  437.           PUSH(sy, 0, 0);
  438.         }    
  439.       break;
  440.     case ieee_function_minus_enum:
  441.         {
  442.           bfd_vma value1, value2;
  443.           asection *section1, *section_dummy;
  444.           ieee_symbol_index_type sy;
  445.           next_byte(&(ieee->h));
  446.  
  447.           POP(sy, section1, value1);
  448.           POP(sy, section_dummy, value2);
  449.           PUSH(sy, section1 ? section1 : section_dummy, value1-value2);
  450.         }
  451.       break;
  452.     case ieee_function_plus_enum:
  453.         {
  454.           bfd_vma value1, value2;
  455.           asection *section1;
  456.           asection *section2;
  457.           ieee_symbol_index_type sy1;
  458.           ieee_symbol_index_type sy2;
  459.           next_byte(&(ieee->h));
  460.  
  461.           POP(sy1, section1, value1);
  462.           POP(sy2, section2, value2);
  463.           PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2);
  464.         }
  465.       break;
  466.     default: 
  467.         {
  468.           bfd_vma va;
  469.           BFD_ASSERT(this_byte(&(ieee->h)) < (int)ieee_variable_A_enum 
  470.              || this_byte(&(ieee->h)) > (int)ieee_variable_Z_enum);
  471.           if (parse_int(&(ieee->h), &va)) 
  472.           {
  473.             PUSH(NOSYMBOL,0, va);
  474.           }
  475.           else {
  476.         /* 
  477.           Thats all that we can understand. As far as I can see
  478.           there is a bug in the Microtec IEEE output which I'm
  479.           using to scan, whereby the comma operator is ommited
  480.           sometimes in an expression, giving expressions with too
  481.           many terms. We can tell if that's the case by ensuring
  482.           that sp == stack here. If not, then we've pushed
  483.           something too far, so we keep adding
  484.           */
  485.  
  486.         while (sp != stack+1) {
  487.           asection *section1;
  488.           ieee_symbol_index_type sy1;
  489.           POP(sy1, section1, *extra);
  490.         }
  491.  
  492.         POP(*symbol, *section, *value);
  493.         loop = false;
  494.           }
  495.         }
  496.  
  497.     }
  498.   }
  499. }
  500.  
  501.  
  502.  
  503. #define ieee_seek(abfd, offset) \
  504.   ieee_data(abfd)->h.input_p = ieee_data(abfd)->h.first_byte + offset
  505.  
  506. #define ieee_pos(abfd)   ieee_data(abfd)->h.input_p -ieee_data(abfd)->h.first_byte 
  507.  
  508. static unsigned int last_index;
  509.  
  510. static ieee_symbol_type *
  511. DEFUN(get_symbol,(abfd, 
  512.           ieee,  
  513.           last_symbol,
  514.           symbol_count,
  515. pptr,
  516. max_index
  517.           ),
  518.       bfd *abfd AND
  519.       ieee_data_type *ieee AND
  520.       ieee_symbol_type *last_symbol AND
  521.       unsigned int *symbol_count AND
  522.           ieee_symbol_type *** pptr AND
  523.       unsigned int *max_index
  524.       )
  525. {
  526.   /* Need a new symbol */
  527.   unsigned int new_index = must_parse_int(&(ieee->h));
  528.   if (new_index != last_index) {
  529.     ieee_symbol_type  *   new_symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd,
  530.                                      sizeof(ieee_symbol_type));
  531.  
  532.     new_symbol->index = new_index;
  533.     last_index = new_index;
  534.     ( *symbol_count)++;    
  535.     ** pptr= new_symbol;
  536.     *pptr = &new_symbol->next;
  537.     if (new_index > *max_index) {
  538.       *max_index = new_index;
  539.     }
  540.     return new_symbol;
  541.   }
  542.   return last_symbol;
  543. }
  544. static void
  545. DEFUN(ieee_slurp_external_symbols,(abfd),
  546.       bfd *abfd)
  547. {
  548.   ieee_data_type *ieee = ieee_data(abfd);
  549.   file_ptr offset = ieee->w.r.external_part;
  550.  
  551.  
  552.   ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
  553.   ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
  554.   ieee_symbol_type  *symbol = (ieee_symbol_type *)NULL;
  555.   unsigned int symbol_count = 0;
  556.   boolean loop = true;
  557.   last_index = 0xffffff;
  558.   ieee->symbol_table_full = true;
  559.  
  560.   ieee_seek(abfd, offset );
  561.  
  562.   while (loop) {
  563.     switch (this_byte(&(ieee->h))) {
  564.     case ieee_nn_record:
  565.       next_byte(&(ieee->h));
  566.       symbol = get_symbol(abfd, ieee, symbol, &symbol_count,
  567.               &prev_symbols_ptr, 
  568.               &ieee->external_symbol_max_index);
  569.  
  570.       symbol->symbol.the_bfd = abfd;
  571.       symbol->symbol.name = read_id(&(ieee->h));
  572.       symbol->symbol.udata = (PTR)NULL;
  573.       symbol->symbol.flags = BSF_NO_FLAGS;
  574.  
  575.       
  576.       break;
  577.     case ieee_external_symbol_enum:
  578.       next_byte(&(ieee->h));
  579.                          
  580.       symbol = get_symbol(abfd, ieee, symbol, &symbol_count,
  581.               &prev_symbols_ptr,
  582.               &ieee->external_symbol_max_index);
  583.  
  584.  
  585.       BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
  586.  
  587.       symbol->symbol.the_bfd = abfd;
  588.       symbol->symbol.name = read_id(&(ieee->h));
  589.       symbol->symbol.udata = (PTR)NULL;
  590.       symbol->symbol.flags = BSF_NO_FLAGS;
  591.       break;
  592.     case ieee_attribute_record_enum >> 8:
  593.     {
  594.       unsigned int symbol_name_index;
  595.       unsigned int symbol_type_index;
  596.       unsigned int symbol_attribute_def;
  597.       bfd_vma value;
  598.       next_byte(&(ieee->h)); /* Skip prefix */
  599.       next_byte(&(ieee->h));
  600.       symbol_name_index = must_parse_int(&(ieee->h));
  601.       symbol_type_index = must_parse_int(&(ieee->h));
  602.       symbol_attribute_def = must_parse_int(&(ieee->h));
  603.       switch (symbol_attribute_def) {
  604.       case 63:
  605.         /* Module misc; followed by two fields which describe the
  606.            current module block. The first fired is the type id
  607.            number, the second is the number of asn records
  608.            associated with the directive */
  609.         parse_int(&(ieee->h),&value);
  610.         parse_int(&(ieee->h),&value);
  611.         break;
  612.  
  613.       default:
  614.         parse_int(&(ieee->h),&value);
  615.         break;
  616.       }
  617.     }
  618.       break;
  619.     case ieee_value_record_enum >> 8:
  620.     {
  621.       unsigned int symbol_name_index;
  622.       ieee_symbol_index_type symbol_ignore;
  623.       boolean pcrel_ignore;
  624.       unsigned int extra;
  625.       next_byte(&(ieee->h));
  626.       next_byte(&(ieee->h));
  627.  
  628.       symbol_name_index = must_parse_int(&(ieee->h));
  629.       parse_expression(ieee,
  630.                &symbol->symbol.value,
  631.                &symbol->symbol.section,
  632.                &symbol_ignore, 
  633.                &pcrel_ignore, 
  634.                &extra);
  635.       if (symbol->symbol.section != (asection *)NULL) {
  636.         symbol->symbol.flags  = BSF_GLOBAL | BSF_EXPORT;
  637.       }
  638.       else {
  639.         symbol->symbol.flags  = BSF_GLOBAL | BSF_EXPORT | BSF_ABSOLUTE;
  640.       }
  641.     }
  642.       break;
  643.     case ieee_weak_external_reference_enum:
  644.     { bfd_vma size;
  645.       bfd_vma value ;
  646.       next_byte(&(ieee->h));
  647.       /* Throw away the external reference index */
  648.       (void)must_parse_int(&(ieee->h));
  649.       /* Fetch the default size if not resolved */
  650.       size = must_parse_int(&(ieee->h));
  651.       /* Fetch the defautlt value if available */
  652.       if (  parse_int(&(ieee->h), &value) == false) {
  653.         value = 0;
  654.       }
  655.       /* This turns into a common */
  656.       symbol->symbol.flags = BSF_FORT_COMM;
  657.       symbol->symbol.value = size;
  658.     }
  659.       break;
  660.  
  661.     case ieee_external_reference_enum: 
  662.       next_byte(&(ieee->h));
  663.  
  664.       symbol = get_symbol(abfd, ieee, symbol, &symbol_count,
  665.               &prev_reference_ptr,
  666.               &ieee->external_reference_max_index);
  667.  
  668.  
  669.       symbol->symbol.the_bfd = abfd;
  670.       symbol->symbol.name = read_id(&(ieee->h));
  671.       symbol->symbol.udata = (PTR)NULL;
  672.       symbol->symbol.section = (asection *)NULL;
  673.       symbol->symbol.value = (bfd_vma)0;
  674.       symbol->symbol.flags = BSF_UNDEFINED;
  675.  
  676.       BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
  677.       break;
  678.  
  679.     default:
  680.       loop = false;
  681.     }
  682.   }
  683.  
  684.   if (ieee->external_symbol_max_index != 0) {
  685.     ieee->external_symbol_count = 
  686.       ieee->external_symbol_max_index -
  687.     ieee->external_symbol_min_index + 1  ;
  688.   }
  689.   else  {
  690.     ieee->external_symbol_count = 0;
  691.   }
  692.  
  693.  
  694.   if(ieee->external_reference_max_index != 0) {
  695.     ieee->external_reference_count = 
  696.       ieee->external_reference_max_index -
  697.     ieee->external_reference_min_index + 1;
  698.   }
  699.   else {
  700.     ieee->external_reference_count = 0;
  701.   }
  702.  
  703.   abfd->symcount =
  704.     ieee->external_reference_count +  ieee->external_symbol_count;
  705.  
  706.   if (symbol_count != abfd->symcount) {
  707.     /* There are gaps in the table -- */
  708.     ieee->symbol_table_full = false;
  709.   }
  710.  
  711.  
  712.   *prev_symbols_ptr = (ieee_symbol_type *)NULL;
  713.   *prev_reference_ptr = (ieee_symbol_type *)NULL;
  714. }
  715.  
  716. static void
  717. DEFUN(ieee_slurp_symbol_table,(abfd),
  718.       bfd *abfd)
  719. {
  720.   if (ieee_data(abfd)->read_symbols == false) {
  721.     ieee_slurp_external_symbols(abfd);
  722.     ieee_data(abfd)->read_symbols= true;
  723.   }
  724. }
  725.  
  726. unsigned int
  727. DEFUN(ieee_get_symtab_upper_bound,(abfd),
  728.       bfd *abfd)
  729. {
  730.   ieee_slurp_symbol_table (abfd);
  731.  
  732.   return (abfd->symcount != 0) ? 
  733.     (abfd->symcount+1) * (sizeof (ieee_symbol_type *)) : 0;
  734. }
  735.  
  736. /* 
  737. Move from our internal lists to the canon table, and insert in
  738. symbol index order
  739. */
  740.  
  741. extern bfd_target ieee_vec;
  742. unsigned int
  743. DEFUN(ieee_get_symtab,(abfd, location),
  744.       bfd *abfd AND
  745.       asymbol **location)
  746. {
  747.   ieee_symbol_type *symp;
  748.   static bfd dummy_bfd;
  749.   static asymbol empty_symbol =
  750.     { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_ABSOLUTE};
  751.  
  752. if (abfd->symcount) {
  753.  
  754.  
  755.  
  756.  
  757.   ieee_data_type *ieee = ieee_data(abfd);
  758.   dummy_bfd.xvec= &ieee_vec;
  759.   ieee_slurp_symbol_table(abfd);
  760.  
  761.   if (ieee->symbol_table_full == false) {
  762.     /* Arrgh - there are gaps in the table, run through and fill them */
  763.     /* up with pointers to a null place */
  764.     unsigned int i;
  765.     for (i= 0; i < abfd->symcount; i++) {
  766.       location[i] = &empty_symbol;
  767.     }
  768.   }
  769.  
  770.  
  771.   ieee->external_symbol_base_offset= -  ieee->external_symbol_min_index;
  772.   for (symp = ieee_data(abfd)->external_symbols;
  773.        symp != (ieee_symbol_type *)NULL;
  774.        symp = symp->next) {
  775.     /* Place into table at correct index locations */
  776.     location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
  777.  
  778.   }
  779.  
  780.   /* The external refs are indexed in a bit */
  781.   ieee->external_reference_base_offset   =
  782.     -  ieee->external_reference_min_index +ieee->external_symbol_count ;
  783.  
  784.   for (symp = ieee_data(abfd)->external_reference;
  785.        symp != (ieee_symbol_type *)NULL;
  786.        symp = symp->next) {
  787.     location[symp->index + ieee->external_reference_base_offset] =
  788.       &symp->symbol;
  789.  
  790.   }
  791.  
  792.  
  793.  
  794.   location[abfd->symcount] = (asymbol *)NULL;
  795. }
  796.   return abfd->symcount;
  797. }
  798. static asection *
  799. DEFUN(get_section_entry,(abfd, ieee,index),
  800.  bfd *abfd AND
  801.      ieee_data_type *ieee AND
  802.       unsigned int index)
  803. {
  804.   if (ieee->section_table[index] == (asection *)NULL) {
  805.     asection *section = bfd_make_section(abfd, " tempname");
  806.     ieee->section_table[index] = section;
  807.     section->flags = SEC_NO_FLAGS;
  808.     section->target_index = index;
  809.     ieee->section_table[index] = section;
  810.   }
  811.   return ieee->section_table[index];
  812. }
  813.  
  814. static void
  815. DEFUN(ieee_slurp_sections,(abfd),
  816.       bfd *abfd)
  817. {
  818.   ieee_data_type *ieee = ieee_data(abfd);
  819.   file_ptr offset = ieee->w.r.section_part;
  820.  
  821.   asection *section = (asection *)NULL;
  822.  
  823.   if (offset != 0) {
  824.     bfd_byte section_type[3];
  825.     ieee_seek(abfd, offset);
  826.     while (true) {
  827.       switch (this_byte(&(ieee->h))) {
  828.       case ieee_section_type_enum:
  829.       {
  830.         unsigned int section_index ;
  831.         next_byte(&(ieee->h));
  832.         section_index = must_parse_int(&(ieee->h));
  833.         /* Fixme to be nice about a silly number of sections */
  834.         BFD_ASSERT(section_index < NSECTIONS);
  835.  
  836.         section =get_section_entry(abfd, ieee, section_index);
  837.  
  838.         section_type[0] =  this_byte_and_next(&(ieee->h));
  839.         switch (section_type[0]) {
  840.         case 0xC1:
  841.           /* Normal attributes for absolute sections    */
  842.           section_type[1] = this_byte(&(ieee->h));
  843.           section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
  844.           switch(section_type[1]) {
  845.           case 0xD3:
  846.         next_byte(&(ieee->h));
  847.         section_type[2] = this_byte(&(ieee->h));
  848.         switch (section_type[2]) 
  849.             {
  850.             case 0xD0:
  851.               /* Normal code */
  852.               next_byte(&(ieee->h));
  853.               section->flags |= SEC_LOAD | SEC_CODE;
  854.               break;
  855.             case 0xC4:
  856.               next_byte(&(ieee->h));
  857.               section->flags |= SEC_LOAD  | SEC_DATA;
  858.               /* Normal data */
  859.               break;
  860.             case 0xD2:
  861.               next_byte(&(ieee->h));
  862.               /* Normal rom data */
  863.               section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
  864.               break;
  865.             default:
  866.               break;
  867.             }
  868.           }
  869.           break;
  870.         case 0xC3:
  871.           section_type[1] = this_byte(&(ieee->h));
  872.           section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
  873.           switch (section_type[1]) {
  874.           case 0xD0:
  875.         /* Normal code */
  876.         next_byte(&(ieee->h));
  877.         section->flags |= SEC_LOAD | SEC_CODE;
  878.         break;
  879.           case 0xC4:
  880.         next_byte(&(ieee->h));
  881.         section->flags |= SEC_LOAD  | SEC_DATA;
  882.         /* Normal data */
  883.         break;
  884.           case 0xD2:
  885.         next_byte(&(ieee->h));
  886.         /* Normal rom data */
  887.         section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
  888.         break;
  889.           default:
  890.         break;
  891.           }
  892.         }
  893.         section->name = read_id(&(ieee->h));
  894.           { bfd_vma parent, brother, context;
  895.         parse_int(&(ieee->h), &parent);
  896.         parse_int(&(ieee->h), &brother);
  897.         parse_int(&(ieee->h), &context);
  898.           }
  899.  
  900.  
  901.       }
  902.     break;
  903.       case ieee_section_alignment_enum:
  904.       { 
  905.         unsigned int section_index;
  906.         bfd_vma value;
  907.         asection *section;
  908.         next_byte(&(ieee->h));
  909.         section_index = must_parse_int(&ieee->h);
  910.         section = get_section_entry(abfd, ieee, section_index);
  911.         if (section_index > ieee->section_count) {
  912.           ieee->section_count = section_index;
  913.         }
  914.         section->alignment_power =
  915.           bfd_log2(must_parse_int(&ieee->h));
  916.         (void)parse_int(&(ieee->h), & value);
  917.       }
  918.     break;
  919.       case ieee_e2_first_byte_enum: 
  920.       {
  921.         ieee_record_enum_type t = (ieee_record_enum_type)(read_2bytes(&(ieee->h)));
  922.  
  923.         switch (t) {
  924.         case ieee_section_size_enum:
  925.           section = ieee->section_table[must_parse_int(&(ieee->h))];
  926.           section->size = must_parse_int(&(ieee->h));
  927.           break;
  928.         case ieee_physical_region_size_enum:
  929.           section = ieee->section_table[must_parse_int(&(ieee->h))];
  930.           section->size = must_parse_int(&(ieee->h));
  931.           break;
  932.         case ieee_region_base_address_enum:
  933.           section = ieee->section_table[must_parse_int(&(ieee->h))];
  934.           section->vma = must_parse_int(&(ieee->h));
  935.           break;
  936.         case ieee_mau_size_enum:
  937.           must_parse_int(&(ieee->h));
  938.           must_parse_int(&(ieee->h));
  939.           break;
  940.         case ieee_m_value_enum:
  941.           must_parse_int(&(ieee->h));
  942.           must_parse_int(&(ieee->h));
  943.           break;
  944.         case ieee_section_base_address_enum:
  945.           section = ieee->section_table[must_parse_int(&(ieee->h))];
  946.           section->vma = must_parse_int(&(ieee->h));
  947.           break;
  948.         case ieee_section_offset_enum:
  949.           (void) must_parse_int(&(ieee->h));
  950.           (void) must_parse_int(&(ieee->h));
  951.           break;
  952.         default:
  953.           return;
  954.         }
  955.       }
  956.     break;
  957.       default:
  958.     return;
  959.       }
  960.     }
  961.   }
  962. }
  963.  
  964. /***********************************************************************
  965. *  archive stuff 
  966. */
  967. bfd_target *
  968. DEFUN(ieee_archive_p,(abfd),
  969.       bfd *abfd)
  970. {
  971.   char *library;
  972.   boolean loop;
  973.  
  974.   unsigned int i;
  975. uint8e_type buffer[512];
  976.  
  977.   int buffer_offset = 0;
  978.   ieee_ar_data_type *save = ieee_ar_data(abfd);
  979.   ieee_ar_data_type *ieee ;
  980.   set_tdata(abfd, bfd_alloc(abfd, sizeof(ieee_ar_data_type)));
  981.   ieee=  ieee_ar_data(abfd);
  982.  
  983.  
  984.   bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
  985.  
  986.   ieee->h.first_byte = buffer;
  987.   ieee->h.input_p = buffer;
  988.  
  989.   ieee->h.abfd = abfd;
  990.  
  991.   if (this_byte(&(ieee->h)) != Module_Beginning) return (bfd_target*)NULL;
  992.  
  993.   next_byte(&(ieee->h));
  994.   library= read_id(&(ieee->h));
  995.   if (strcmp(library , "LIBRARY") != 0) {
  996.     bfd_release(abfd, ieee);
  997.     set_tdata (abfd, save);
  998.     return (bfd_target *)NULL;
  999.   }
  1000.   /* Throw away the filename */
  1001.   free( read_id(&(ieee->h)));
  1002.   /* This must be an IEEE archive, so we'll buy some space to do
  1003.      things */
  1004.   ieee->element_count = 0;
  1005.   ieee->element_index = 0;
  1006.  
  1007.   next_byte(&(ieee->h));    /* Drop the ad part */
  1008.   must_parse_int(&(ieee->h));    /* And the two dummy numbers */
  1009.   must_parse_int(&(ieee->h));
  1010.  
  1011.   loop = true;
  1012.   /* Read the index of the BB table */
  1013.   while (loop) {
  1014.     ieee_ar_obstack_type t; 
  1015.     int rec =read_2bytes(&(ieee->h));
  1016.     if (rec ==(int)ieee_assign_value_to_variable_enum) {
  1017.       int record_number = must_parse_int(&(ieee->h));
  1018.       t.file_offset = must_parse_int(&(ieee->h));
  1019.       t.abfd = (bfd *)NULL;
  1020.       ieee->element_count++;
  1021.       bfd_alloc_grow(abfd, (PTR)&t, sizeof(t));
  1022.  
  1023.       /* Make sure that we don't go over the end of the buffer */
  1024.  
  1025.       if (ieee_pos(abfd) > sizeof(buffer)/2) {
  1026.     /* Past half way, reseek and reprime */
  1027.     buffer_offset += ieee_pos(abfd);
  1028.     bfd_seek(abfd, buffer_offset, SEEK_SET);
  1029.     bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
  1030.     ieee->h.first_byte = buffer;
  1031.     ieee->h.input_p = buffer;
  1032.       }
  1033.     }
  1034.     else loop = false;
  1035.   }
  1036.  
  1037.   ieee->elements = (ieee_ar_obstack_type *)bfd_alloc_finish(abfd);
  1038.  
  1039.   /* Now scan the area again, and replace BB offsets with file */
  1040.   /* offsets */
  1041.  
  1042.  
  1043.   for (i = 2; i < ieee->element_count; i++) {
  1044.     bfd_seek(abfd, ieee->elements[i].file_offset, SEEK_SET);
  1045.     bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
  1046.     ieee->h.first_byte = buffer;
  1047.     ieee->h.input_p = buffer;
  1048.     
  1049.     next_byte(&(ieee->h));    /* Drop F8 */
  1050.     next_byte(&(ieee->h));    /* Drop 14 */
  1051.     must_parse_int(&(ieee->h));    /* Drop size of block */
  1052.     if (must_parse_int(&(ieee->h)) != 0) {
  1053.       /* This object has been deleted */
  1054.       ieee->elements[i].file_offset = 0;
  1055.     }
  1056.     else {
  1057.       ieee->elements[i].file_offset = must_parse_int(&(ieee->h));
  1058.     }
  1059.   }
  1060.  
  1061.   return abfd->xvec;
  1062.  
  1063. }
  1064.  
  1065. static boolean
  1066. DEFUN(ieee_mkobject,(abfd),
  1067.       bfd *abfd)
  1068. { 
  1069.   set_tdata (abfd, bfd_zalloc(abfd,sizeof(ieee_data_type)));
  1070.   
  1071.  
  1072.   return true;
  1073. }
  1074.  
  1075. bfd_target *
  1076. DEFUN(ieee_object_p,(abfd),
  1077.       bfd *abfd)
  1078. {
  1079.   char *processor;
  1080.   unsigned int part;
  1081.   ieee_data_type *ieee;
  1082.   uint8e_type buffer[300];
  1083.   ieee_data_type *save = ieee_data(abfd);
  1084.   set_tdata (abfd, 0);
  1085.   ieee_mkobject(abfd);
  1086.   ieee = ieee_data(abfd);
  1087.   
  1088.   /* Read the first few bytes in to see if it makes sense */
  1089.   bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
  1090.  
  1091.   ieee->h.input_p = buffer;
  1092.   if (this_byte_and_next(&(ieee->h)) != Module_Beginning) goto fail;
  1093.  
  1094.   ieee->read_symbols= false;
  1095.   ieee->read_data= false;
  1096.   ieee->section_count = 0;
  1097.   ieee->external_symbol_max_index = 0;
  1098.   ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
  1099.   ieee->external_reference_min_index =IEEE_REFERENCE_BASE;
  1100.   ieee->external_reference_max_index = 0;
  1101.   ieee->h.abfd = abfd;
  1102.   memset((PTR)ieee->section_table, 0,     sizeof(ieee->section_table));
  1103.  
  1104.   processor = ieee->mb.processor = read_id(&(ieee->h));
  1105.   if (strcmp(processor,"LIBRARY") == 0) goto fail;
  1106.   ieee->mb.module_name = read_id(&(ieee->h));
  1107.   if (abfd->filename == (char *)NULL) {
  1108.     abfd->filename =  ieee->mb.module_name;
  1109.   }
  1110.   /* Determine the architecture and machine type of the object file.
  1111.      */
  1112.     {
  1113.       bfd_arch_info_type *arch = bfd_scan_arch(processor);
  1114.       if (arch == 0) goto fail;
  1115.       abfd->arch_info = arch;
  1116.     }
  1117.  
  1118.   if (this_byte(&(ieee->h)) != (int)ieee_address_descriptor_enum) {
  1119.     goto fail;
  1120.   }
  1121.   next_byte(&(ieee->h));    
  1122.  
  1123.   if (parse_int(&(ieee->h), &ieee->ad.number_of_bits_mau) == false) {
  1124.     goto fail;
  1125.   }
  1126.   if(parse_int(&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) {
  1127.     goto fail;
  1128.   }
  1129.  
  1130.   /* If there is a byte order info, take it */
  1131.   if (this_byte(&(ieee->h)) == (int)ieee_variable_L_enum ||
  1132.       this_byte(&(ieee->h)) == (int)ieee_variable_M_enum)
  1133.     next_byte(&(ieee->h));
  1134.  
  1135.  
  1136.   for (part = 0; part < N_W_VARIABLES; part++) {
  1137.     boolean ok;
  1138.     if (read_2bytes(&(ieee->h)) != (int) ieee_assign_value_to_variable_enum) {
  1139.       goto fail;
  1140.     }
  1141.     if (this_byte_and_next(&(ieee->h)) != part)  {
  1142.       goto fail;
  1143.     }
  1144.  
  1145.     ieee->w.offset[part] = parse_i(&(ieee->h), &ok);
  1146.     if (ok==false) {
  1147.       goto fail;
  1148.     }
  1149.  
  1150.   }
  1151.   abfd->flags = HAS_SYMS;
  1152.  
  1153. /* By now we know that this is a real IEEE file, we're going to read
  1154.    the whole thing into memory so that we can run up and down it
  1155.    quickly. We can work out how big the file is from the trailer
  1156.    record */
  1157.  
  1158.   ieee_data(abfd)->h.first_byte = (uint8e_type *) bfd_alloc(ieee->h.abfd, ieee->w.r.me_record
  1159.                         + 50);
  1160.   bfd_seek(abfd, 0, 0);
  1161.   bfd_read((PTR)(ieee_data(abfd)->h.first_byte), 1,   ieee->w.r.me_record+50,  abfd);
  1162.  
  1163.   ieee_slurp_sections(abfd);
  1164.   return abfd->xvec;
  1165.  fail:
  1166.   (void)  bfd_release(abfd, ieee);
  1167.   set_tdata (abfd, save);
  1168.   return (bfd_target *)NULL;
  1169. }
  1170.  
  1171.  
  1172. void 
  1173. DEFUN(ieee_print_symbol,(ignore_abfd, afile,  symbol, how),
  1174.       bfd *ignore_abfd AND
  1175.       PTR afile AND
  1176.       asymbol *symbol AND
  1177.       bfd_print_symbol_type how)
  1178. {
  1179.   FILE *file = (FILE *)afile;
  1180.  
  1181.   switch (how) {
  1182.   case bfd_print_symbol_name:
  1183.     fprintf(file,"%s", symbol->name);
  1184.     break;
  1185.   case bfd_print_symbol_more:
  1186. #if 0
  1187.     fprintf(file,"%4x %2x",aout_symbol(symbol)->desc & 0xffff,
  1188.         aout_symbol(symbol)->other  & 0xff);
  1189. #endif
  1190.     BFD_FAIL();
  1191.     break;
  1192.   case bfd_print_symbol_all:
  1193.       {
  1194.     CONST char *section_name = symbol->section == (asection *)NULL ?
  1195.       "*abs" : symbol->section->name;
  1196.     if (symbol->name[0] == ' ') {
  1197.       fprintf(file,"* empty table entry ");
  1198.     }
  1199.     else {
  1200.       bfd_print_symbol_vandf((PTR)file,symbol);
  1201.  
  1202.       fprintf(file," %-5s %04x %02x %s",
  1203.           section_name,
  1204.           (unsigned)          ieee_symbol(symbol)->index,
  1205.           (unsigned)          0, /*
  1206.                        aout_symbol(symbol)->desc & 0xffff,
  1207.                        aout_symbol(symbol)->other  & 0xff,*/
  1208.           symbol->name);
  1209.     }
  1210.       }
  1211.     break;
  1212.   }
  1213. }
  1214.  
  1215.  
  1216. static void
  1217. DEFUN(do_one,(ieee, current_map, location_ptr,s),
  1218.       ieee_data_type *ieee AND
  1219.       ieee_per_section_type *current_map AND
  1220.       uint8e_type *location_ptr AND
  1221.       asection *s)
  1222. {
  1223.   switch (this_byte(&(ieee->h)))  
  1224.       {
  1225.       case ieee_load_constant_bytes_enum:
  1226.       {
  1227.         unsigned int number_of_maus;
  1228.         unsigned int i;
  1229.         next_byte(&(ieee->h));
  1230.         number_of_maus = must_parse_int(&(ieee->h));
  1231.  
  1232.         for (i = 0; i < number_of_maus; i++) {
  1233.           location_ptr[current_map->pc++]= this_byte(&(ieee->h));
  1234.           next_byte(&(ieee->h));
  1235.         }
  1236.       }
  1237.     break;
  1238.  
  1239.       case ieee_load_with_relocation_enum:
  1240.       {
  1241.         boolean loop = true;
  1242.         next_byte(&(ieee->h));
  1243.         while (loop) 
  1244.         {
  1245.           switch (this_byte(&(ieee->h))) 
  1246.               {
  1247.               case ieee_variable_R_enum:
  1248.  
  1249.               case ieee_function_signed_open_b_enum:
  1250.               case ieee_function_unsigned_open_b_enum:
  1251.               case ieee_function_either_open_b_enum:
  1252.               {
  1253.                 unsigned int extra = 4;
  1254.                 boolean pcrel = false;
  1255.  
  1256.                 ieee_reloc_type *r = 
  1257.                   (ieee_reloc_type *) bfd_alloc(ieee->h.abfd,
  1258.                                 sizeof(ieee_reloc_type));
  1259.  
  1260.                 *(current_map->reloc_tail_ptr) = r;
  1261.                 current_map->reloc_tail_ptr= &r->next;
  1262.                 r->next = (ieee_reloc_type *)NULL;
  1263.                 next_byte(&(ieee->h));
  1264.                 parse_expression(ieee,
  1265.                          &r->relent.addend,
  1266.                          &r->relent.section,
  1267.                          &r->symbol,
  1268.                          &pcrel, &extra);
  1269.                 r->relent.address = current_map->pc;
  1270.                 s->reloc_count++;
  1271.  
  1272.                 if (this_byte(&(ieee->h)) == (int)ieee_comma) {
  1273.                   next_byte(&(ieee->h));
  1274.                   /* Fetch number of bytes to pad */
  1275.                   extra = must_parse_int(&(ieee->h));
  1276.                 };
  1277.            
  1278.                 switch (this_byte(&(ieee->h))) {
  1279.                 case ieee_function_signed_close_b_enum:
  1280.                   next_byte(&(ieee->h));
  1281.                   break;
  1282.                 case ieee_function_unsigned_close_b_enum:
  1283.                   next_byte(&(ieee->h));
  1284.                   break;
  1285.                 case ieee_function_either_close_b_enum:
  1286.                   next_byte(&(ieee->h));
  1287.                   break;
  1288.                 default:
  1289.                   break;
  1290.                 }
  1291.                 /* Build a relocation entry for this type */
  1292.                 /* If pc rel then stick -ve pc into instruction
  1293.                    and take out of reloc ..
  1294.  
  1295.                    I've changed this. It's all too
  1296.                    complicated. I keep 0 in the
  1297.                    instruction  now.
  1298.                    */
  1299.             
  1300.                 switch (extra) 
  1301.                 {
  1302.                 case 0:
  1303.                 case 4:
  1304.                   
  1305.                   if (pcrel == true) 
  1306.                       {
  1307. #if KEEPMINUSPCININST
  1308.                     bfd_put_32(ieee->h.abfd, -current_map->pc, location_ptr +
  1309.                             current_map->pc);
  1310.                     r->relent.howto = &rel32_howto;
  1311.                     r->relent.addend -=
  1312.                       current_map->pc;
  1313. #else
  1314.                     bfd_put_32(ieee->h.abfd,0, location_ptr +
  1315.                             current_map->pc);
  1316.                     r->relent.howto = &rel32_howto;
  1317. #endif
  1318.                       }
  1319.                   else 
  1320.                       {
  1321.                     bfd_put_32(ieee->h.abfd, 0, location_ptr +
  1322.                             current_map->pc);
  1323.                     r->relent.howto = &abs32_howto;
  1324.                       }
  1325.                   current_map->pc +=4;
  1326.                   break;
  1327.                 case 2:
  1328.                   if (pcrel == true) {
  1329. #if KEEPMINUSPCININST
  1330.                     bfd_put_16(ieee->h.abfd, (int)(-current_map->pc),  location_ptr +current_map->pc);
  1331.                     r->relent.addend -= current_map->pc;
  1332.                     r->relent.howto = &rel16_howto;
  1333. #else
  1334.  
  1335.                     bfd_put_16(ieee->h.abfd, 0,  location_ptr +current_map->pc);
  1336.                     r->relent.howto = &rel16_howto;
  1337. #endif
  1338.                   }
  1339.  
  1340.                   else {
  1341.                     bfd_put_16(ieee->h.abfd, 0,  location_ptr +current_map->pc);
  1342.                     r->relent.howto = &abs16_howto;
  1343.                   }
  1344.                   current_map->pc +=2;
  1345.                   break;
  1346.                 case 1:
  1347.                   if (pcrel == true) {
  1348. #if KEEPMINUSPCININST
  1349.                     bfd_put_8(ieee->h.abfd, (int)(-current_map->pc),  location_ptr +current_map->pc);
  1350.                     r->relent.addend -= current_map->pc;
  1351.                     r->relent.howto = &rel8_howto;
  1352. #else
  1353.                     bfd_put_8(ieee->h.abfd,0,  location_ptr +current_map->pc);
  1354.                     r->relent.howto = &rel8_howto;
  1355. #endif
  1356.                   }
  1357.                   else {
  1358.                     bfd_put_8(ieee->h.abfd, 0,  location_ptr +current_map->pc);
  1359.                     r->relent.howto = &abs8_howto;
  1360.                   }
  1361.                   current_map->pc +=1;
  1362.                   break;
  1363.  
  1364.                 default:
  1365.                   BFD_FAIL();
  1366.                   break;
  1367.                 }
  1368.               }
  1369.             break;
  1370.               default: 
  1371.               {
  1372.                 bfd_vma this_size ;
  1373.                 if (parse_int(&(ieee->h), &this_size) == true) {
  1374.                   unsigned int i;
  1375.                   for (i = 0; i < this_size; i++) {
  1376.                 location_ptr[current_map->pc ++] = this_byte(&(ieee->h));
  1377.                 next_byte(&(ieee->h));
  1378.                   }
  1379.                 }
  1380.                 else {
  1381.                   loop = false;
  1382.                 }
  1383.               }
  1384.               }
  1385.         }
  1386.       }
  1387.       }
  1388. }
  1389.  
  1390. /* Read in all the section data and relocation stuff too */
  1391. static boolean 
  1392. DEFUN(ieee_slurp_section_data,(abfd),
  1393.       bfd *abfd)
  1394. {
  1395.   bfd_byte *location_ptr = (bfd_byte *)NULL;
  1396.   ieee_data_type *ieee = ieee_data(abfd);
  1397.   unsigned int section_number ;
  1398.  
  1399.   ieee_per_section_type *current_map = (ieee_per_section_type *)NULL;
  1400.   asection *s;
  1401.   /* Seek to the start of the data area */
  1402.   if (ieee->read_data== true)  return true;
  1403.   ieee->read_data = true;
  1404.   ieee_seek(abfd, ieee->w.r.data_part);
  1405.  
  1406.   /* Allocate enough space for all the section contents */
  1407.  
  1408.  
  1409.   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
  1410.     ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
  1411.     per->data = (bfd_byte *) bfd_alloc(ieee->h.abfd, s->size);
  1412.     /*SUPPRESS 68*/
  1413.     per->reloc_tail_ptr =
  1414.       (ieee_reloc_type **)&(s->relocation);
  1415.   }
  1416.  
  1417.  
  1418.  
  1419.   while (true) {
  1420.     switch (this_byte(&(ieee->h))) 
  1421.     {
  1422.       /* IF we see anything strange then quit */
  1423.     default:
  1424.       return true;
  1425.  
  1426.     case ieee_set_current_section_enum:
  1427.       next_byte(&(ieee->h));
  1428.       section_number = must_parse_int(&(ieee->h));
  1429.       s = ieee->section_table[section_number];
  1430.       current_map = (ieee_per_section_type *) s->used_by_bfd;
  1431.       location_ptr = current_map->data - s->vma;
  1432.       /* The document I have says that Microtec's compilers reset */
  1433.       /* this after a sec section, even though the standard says not */
  1434.       /* to. SO .. */
  1435.       current_map->pc =s->vma;
  1436.       break;
  1437.  
  1438.  
  1439.     case ieee_e2_first_byte_enum:
  1440.       next_byte(&(ieee->h));
  1441.       switch (this_byte(&(ieee->h)))
  1442.           {
  1443.           case ieee_set_current_pc_enum & 0xff:
  1444.           {
  1445.             bfd_vma value;
  1446.             asection *dsection;
  1447.             ieee_symbol_index_type symbol;
  1448.             unsigned int extra;
  1449.             boolean pcrel;
  1450.             next_byte(&(ieee->h));
  1451.             must_parse_int(&(ieee->h)); /* Thow away section #*/
  1452.             parse_expression(ieee, &value, &dsection, &symbol,
  1453.                      &pcrel, &extra);
  1454.             current_map->pc = value;
  1455.             BFD_ASSERT((unsigned)(value - s->vma) <= s->size);
  1456.           }
  1457.         break;
  1458.  
  1459.           case ieee_value_starting_address_enum & 0xff:
  1460.         /* We've got to the end of the data now - */
  1461.         return true;
  1462.           default:
  1463.         BFD_FAIL();
  1464.         return true;
  1465.           }
  1466.       break;
  1467.     case ieee_repeat_data_enum:
  1468.         {
  1469.           /* Repeat the following LD or LR n times - we do this by
  1470.          remembering the stream pointer before running it and
  1471.          resetting it and running it n times. We special case
  1472.          the repetition of a repeat_data/load_constant
  1473.          */
  1474.  
  1475.           unsigned int iterations ;
  1476.           uint8e_type *start ;
  1477.           next_byte(&(ieee->h));
  1478.           iterations = must_parse_int(&(ieee->h));
  1479.           start =  ieee->h.input_p;
  1480.           if (start[0] == (int)ieee_load_constant_bytes_enum &&
  1481.           start[1] == 1) {
  1482.         while (iterations != 0) {
  1483.           location_ptr[current_map->pc++] = start[2];
  1484.           iterations--;
  1485.         }
  1486.         next_byte(&(ieee->h));
  1487.         next_byte(&(ieee->h));
  1488.         next_byte(&(ieee->h));
  1489.           }
  1490.           else {
  1491.         while (iterations != 0) {
  1492.           ieee->h.input_p = start;
  1493.           do_one(ieee, current_map, location_ptr,s);
  1494.           iterations --;
  1495.         }
  1496.           }
  1497.         }
  1498.       break;
  1499.     case ieee_load_constant_bytes_enum:
  1500.     case ieee_load_with_relocation_enum:
  1501.         {
  1502.           do_one(ieee, current_map, location_ptr,s);
  1503.         }
  1504.     }
  1505.   }
  1506. }
  1507.  
  1508.  
  1509.  
  1510.  
  1511.  
  1512. boolean
  1513. DEFUN(ieee_new_section_hook,(abfd, newsect),
  1514.       bfd *abfd AND
  1515.       asection *newsect)
  1516. {
  1517.   newsect->used_by_bfd = (PTR)
  1518.     bfd_alloc(abfd, sizeof(ieee_per_section_type));
  1519.   ieee_per_section( newsect)->data = (bfd_byte *)NULL;
  1520.   ieee_per_section(newsect)->section = newsect;
  1521.   return true;
  1522. }
  1523.  
  1524.  
  1525. unsigned int
  1526. DEFUN(ieee_get_reloc_upper_bound,(abfd, asect),
  1527.       bfd *abfd AND
  1528.       sec_ptr asect)
  1529. {
  1530.   ieee_slurp_section_data(abfd);
  1531.   return (asect->reloc_count+1) * sizeof(arelent *);
  1532. }
  1533.  
  1534. static boolean
  1535. DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count),
  1536.       bfd *abfd AND
  1537.       sec_ptr section AND
  1538.       PTR location AND
  1539.       file_ptr offset AND
  1540.       bfd_size_type count)
  1541. {
  1542.   ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
  1543.   ieee_slurp_section_data(abfd);
  1544.   (void)  memcpy((PTR)location, (PTR)(p->data + offset), (unsigned)count);
  1545.   return true;
  1546. }
  1547.  
  1548.  
  1549. unsigned int
  1550. DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols),
  1551.       bfd *abfd AND
  1552.       sec_ptr section AND
  1553.       arelent **relptr AND
  1554.       asymbol **symbols)
  1555. {
  1556. /*  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
  1557.   ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation);
  1558.   ieee_data_type *ieee = ieee_data(abfd);
  1559.  
  1560.   while (src != (ieee_reloc_type *)NULL) {
  1561.     /* Work out which symbol to attach it this reloc to */
  1562.     switch (src->symbol.letter) {
  1563.     case 'X':
  1564.       src->relent.sym_ptr_ptr =
  1565.     symbols + src->symbol.index +  ieee->external_reference_base_offset;
  1566.       break;
  1567.     case 0:
  1568.       src->relent.sym_ptr_ptr = (asymbol **)NULL;
  1569.       break;
  1570.     default:
  1571.  
  1572.       BFD_FAIL();
  1573.     }
  1574.     *relptr++ = &src->relent;
  1575.     src = src->next;
  1576.   }
  1577.   *relptr = (arelent *)NULL;
  1578.   return section->reloc_count;
  1579. }
  1580.  
  1581.  
  1582.  
  1583. static int 
  1584. DEFUN(comp,(ap, bp),
  1585.      CONST PTR ap AND
  1586.      CONST PTR bp)
  1587. {
  1588.   arelent *a = *((arelent **)ap);
  1589.   arelent *b = *((arelent **)bp);
  1590.   return a->address - b->address;
  1591. }
  1592.  
  1593. /*
  1594. Write the section headers
  1595. */
  1596.  
  1597. static void
  1598. DEFUN(ieee_write_section_part,(abfd),
  1599.       bfd *abfd)
  1600. {
  1601.   ieee_data_type *ieee = ieee_data(abfd);
  1602.   asection *s;
  1603.   ieee->w.r.section_part = bfd_tell(abfd);
  1604.   for (s = abfd->sections; s != (asection *)NULL; s=s->next) {
  1605.     ieee_write_byte(abfd, ieee_section_type_enum);
  1606.     ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1607.  
  1608.     if (abfd->flags & EXEC_P) 
  1609.     {
  1610.       /* This image is executable, so output absolute sections */
  1611.       ieee_write_byte(abfd, ieee_variable_A_enum);
  1612.       ieee_write_byte(abfd, ieee_variable_S_enum);
  1613.     }
  1614.     else  
  1615.     {
  1616.       ieee_write_byte(abfd, ieee_variable_C_enum);
  1617.     }
  1618.  
  1619.     switch (s->flags &(SEC_CODE | SEC_DATA | SEC_ROM)) 
  1620.     {
  1621.     case SEC_CODE | SEC_LOAD:
  1622.     case SEC_CODE:
  1623.       ieee_write_byte(abfd, ieee_variable_P_enum);
  1624.       break;
  1625.     case SEC_DATA:
  1626.     default:
  1627.       ieee_write_byte(abfd, ieee_variable_D_enum);
  1628.       break;
  1629.     case SEC_ROM:
  1630.     case SEC_ROM | SEC_DATA:
  1631.     case SEC_ROM | SEC_LOAD:
  1632.     case SEC_ROM | SEC_DATA | SEC_LOAD:
  1633.  
  1634.       ieee_write_byte(abfd, ieee_variable_R_enum);
  1635.     }
  1636.  
  1637.  
  1638.     ieee_write_id(abfd, s->name);
  1639. #if 0
  1640.     ieee_write_int(abfd, 0);    /* Parent */
  1641.     ieee_write_int(abfd, 0);    /* Brother */
  1642.     ieee_write_int(abfd, 0);    /* Context */
  1643. #endif
  1644.     /* Alignment */
  1645.     ieee_write_byte(abfd, ieee_section_alignment_enum);
  1646.     ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1647.     ieee_write_int(abfd, 1 << s->alignment_power);
  1648.  
  1649.     /* Size */
  1650.     ieee_write_2bytes(abfd, ieee_section_size_enum);
  1651.     ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1652.     ieee_write_int(abfd, s->size);
  1653.     if (abfd->flags & EXEC_P) {
  1654.       /* Relocateable sections don't have asl records */
  1655.       /* Vma */
  1656.       ieee_write_2bytes(abfd, ieee_section_base_address_enum);
  1657.       ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1658.       ieee_write_int(abfd, s->vma);
  1659.     }
  1660.  
  1661.   }
  1662. }
  1663.  
  1664.  
  1665.  
  1666. static void 
  1667. DEFUN(do_with_relocs,(abfd, s),
  1668.       bfd *abfd AND
  1669.       asection *s)
  1670. {
  1671.   unsigned int relocs_to_go = s->reloc_count;
  1672.  
  1673.  
  1674.   bfd_byte *stream = ieee_per_section(s)->data;
  1675.   arelent **p = s->orelocation;
  1676.  
  1677.   bfd_size_type current_byte_index = 0;
  1678.  
  1679.   qsort(s->orelocation,
  1680.     relocs_to_go,
  1681.     sizeof(arelent **),
  1682.     comp);
  1683.  
  1684.   /* Output the section preheader */
  1685.   ieee_write_byte(abfd, ieee_set_current_section_enum);
  1686.   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1687.  
  1688.   ieee_write_twobyte(abfd, ieee_set_current_pc_enum);
  1689.   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1690.   ieee_write_expression(abfd, 0, s, 0, 0, 0);
  1691.  
  1692.   if (relocs_to_go == 0) 
  1693.       {
  1694.     /* If there arn't any relocations then output the load constant byte
  1695.        opcode rather than the load with relocation opcode */
  1696.  
  1697.     while (current_byte_index < s->size) {
  1698.       bfd_size_type run;
  1699.       unsigned int MAXRUN  = 32;
  1700.       run = MAXRUN;
  1701.       if (run > s->size - current_byte_index) {
  1702.         run = s->size - current_byte_index;
  1703.       }
  1704.  
  1705.       if (run != 0) {
  1706.         ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
  1707.         /* Output a stream of bytes */
  1708.         ieee_write_int(abfd, run);
  1709.         bfd_write((PTR)(stream + current_byte_index), 
  1710.               1,
  1711.               run,
  1712.               abfd);
  1713.         current_byte_index += run;
  1714.       }
  1715.     }
  1716.       }
  1717.   else 
  1718.       {
  1719.     ieee_write_byte(abfd, ieee_load_with_relocation_enum);
  1720.  
  1721.  
  1722.     /* Output the data stream as the longest sequence of bytes
  1723.        possible, allowing for the a reasonable packet size and
  1724.        relocation stuffs */
  1725.  
  1726.     if ((PTR)stream == (PTR)NULL) {
  1727.       /* Outputting a section without data, fill it up */
  1728.       stream = (uint8e_type *)(bfd_alloc(abfd, s->size));
  1729.       memset((PTR)stream, 0, s->size);
  1730.     }
  1731.     while (current_byte_index < s->size) {
  1732.       bfd_size_type run;
  1733.       unsigned int MAXRUN = 32;
  1734.       if (relocs_to_go) {
  1735.         run = (*p)->address - current_byte_index;
  1736.       }
  1737.       else {
  1738.         run = MAXRUN;
  1739.       }
  1740.       if (run > s->size - current_byte_index) {
  1741.         run = s->size - current_byte_index;
  1742.       }
  1743.  
  1744.       if (run != 0) {
  1745.         /* Output a stream of bytes */
  1746.         ieee_write_int(abfd, run);
  1747.         bfd_write((PTR)(stream + current_byte_index), 
  1748.               1,
  1749.               run,
  1750.               abfd);
  1751.         current_byte_index += run;
  1752.       }
  1753.       /* Output any relocations here */
  1754.       if (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
  1755.         while (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
  1756.  
  1757.           arelent *r = *p;
  1758.           bfd_vma ov;
  1759.  
  1760. #if 0
  1761.           if (r->howto->pc_relative) {
  1762.         r->addend += current_byte_index ;
  1763.           }
  1764. #endif
  1765.  
  1766.           switch (r->howto->size) {
  1767.           case 2:
  1768.  
  1769.         ov = bfd_get_32(abfd,
  1770.                 stream+current_byte_index);
  1771.         current_byte_index +=4;
  1772.         break;
  1773.           case 1:
  1774.         ov = bfd_get_16(abfd,
  1775.                 stream+current_byte_index);
  1776.         current_byte_index +=2;
  1777.         break;
  1778.           case 0:
  1779.         ov = bfd_get_8(abfd,
  1780.                    stream+current_byte_index);
  1781.         current_byte_index ++;
  1782.         break;
  1783.           default:
  1784.         ov = 0;
  1785.         BFD_FAIL();
  1786.           }
  1787.           ieee_write_byte(abfd, ieee_function_either_open_b_enum);
  1788.  
  1789.           if (r->sym_ptr_ptr != (asymbol **)NULL) {
  1790.         ieee_write_expression(abfd, r->addend + ov,
  1791.                       r->section,
  1792.                       *(r->sym_ptr_ptr),
  1793.                       r->howto->pc_relative, s->index);
  1794.           }
  1795.           else {
  1796.         ieee_write_expression(abfd, r->addend + ov,
  1797.                       r->section,
  1798.                       (asymbol *)NULL,
  1799.                       r->howto->pc_relative, s->index);
  1800.           }
  1801.  
  1802.           if (1 || r->howto->size != 2) {
  1803.         ieee_write_byte(abfd, ieee_comma);
  1804.         ieee_write_int(abfd, 1<< r->howto->size);
  1805.           }
  1806.           ieee_write_byte(abfd,
  1807.                   ieee_function_either_close_b_enum);
  1808.  
  1809.           relocs_to_go --;
  1810.           p++;
  1811.         }
  1812.  
  1813.       }
  1814.     }
  1815.       }
  1816. }
  1817.  
  1818. /* If there are no relocations in the output section then we can
  1819. be clever about how we write. We block items up into a max of 127
  1820. bytes */
  1821.  
  1822. static void 
  1823. DEFUN(do_as_repeat, (abfd, s),
  1824.       bfd *abfd AND
  1825.       asection *s)
  1826. {
  1827.   ieee_write_byte(abfd, ieee_set_current_section_enum);
  1828.   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1829.   ieee_write_byte(abfd, ieee_set_current_pc_enum >> 8);
  1830.  ieee_write_byte(abfd, ieee_set_current_pc_enum  & 0xff);
  1831.   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
  1832.   ieee_write_int(abfd,  s->vma );
  1833.  
  1834.   ieee_write_byte(abfd,ieee_repeat_data_enum);
  1835.   ieee_write_int(abfd, s->size);
  1836.   ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
  1837.   ieee_write_byte(abfd, 1);
  1838.   ieee_write_byte(abfd, 0);
  1839. }
  1840.  
  1841. static void 
  1842. DEFUN(do_without_relocs, (abfd, s),
  1843.       bfd *abfd AND
  1844.       asection *s)
  1845. {
  1846.   bfd_byte *stream = ieee_per_section(s)->data;
  1847.  
  1848.   if (stream == 0 || ((s->flags & SEC_LOAD) == 0)) 
  1849.       {
  1850.     do_as_repeat(abfd, s);
  1851.       }
  1852.   else 
  1853.       {
  1854.     unsigned int i;
  1855.     for (i = 0; i < s->size; i++) {
  1856.       if (stream[i] != 0) {
  1857.         do_with_relocs(abfd, s);
  1858.         return;
  1859.       }
  1860.     }
  1861.     do_as_repeat(abfd, s);
  1862.       }
  1863.   
  1864. }
  1865.  
  1866.  
  1867. static unsigned char *output_ptr_start;
  1868. static unsigned char *output_ptr;
  1869. static unsigned char *output_ptr_end;
  1870. static unsigned char *input_ptr_start;
  1871. static unsigned char *input_ptr;
  1872. static unsigned char *input_ptr_end;
  1873. static bfd *input_bfd;
  1874. static bfd *output_bfd;
  1875. static int output_buffer;
  1876.  
  1877. static void fill()
  1878. {
  1879.   bfd_read((PTR)input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
  1880.   input_ptr = input_ptr_start;
  1881. }
  1882. static void flush()
  1883. {
  1884.   bfd_write((PTR)(output_ptr_start),1,output_ptr - output_ptr_start, output_bfd);
  1885.   output_ptr = output_ptr_start;
  1886.   output_buffer++;
  1887. }
  1888.  
  1889. #define THIS() ( *input_ptr )
  1890. #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
  1891. #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end)  flush(); }
  1892.  
  1893. static void write_int(value)
  1894. int value;
  1895. {
  1896.   if (value >= 0 && value <= 127) {
  1897.     OUT(value);
  1898.   }
  1899.   else {
  1900.     unsigned int length;
  1901.     /* How many significant bytes ? */
  1902.     /* FIXME FOR LONGER INTS */
  1903.     if (value & 0xff000000) {
  1904.       length = 4;
  1905.     }
  1906.     else if (value & 0x00ff0000) {
  1907.       length  = 3;
  1908.     }
  1909.     else if (value & 0x0000ff00) {
  1910.       length = 2;
  1911.     }
  1912.     else length = 1;
  1913.  
  1914.     OUT((int)ieee_number_repeat_start_enum + length);
  1915.     switch (length) {
  1916.     case 4:
  1917.       OUT( value >> 24);
  1918.     case 3:
  1919.       OUT( value >> 16);
  1920.     case 2:
  1921.       OUT( value >> 8);
  1922.     case 1:
  1923.       OUT( value);
  1924.     }
  1925.  
  1926.   }
  1927. }
  1928. static void copy_id() 
  1929. {
  1930.   int length  = THIS();
  1931.   char ch;
  1932.   OUT(length);
  1933.   NEXT();
  1934.   while (length--) {
  1935.     ch = THIS();
  1936.     OUT(ch);
  1937.     NEXT();
  1938.   }
  1939. }
  1940. #define VAR(x) ((x | 0x80))
  1941. static void copy_expression()
  1942. {
  1943.   int stack[10];
  1944.   int *tos = stack;
  1945.   int value = 0;
  1946.   while (1) {
  1947.     switch (THIS()) {
  1948.     case 0x84:
  1949.       NEXT();
  1950.       value =  THIS(); NEXT();
  1951.       value = (value << 8) | THIS(); NEXT();
  1952.       value = (value << 8) | THIS(); NEXT();
  1953.       value = (value << 8) | THIS(); NEXT();
  1954.       *tos ++ = value;
  1955.       break;
  1956.     case 0x83:
  1957.       NEXT();
  1958.       value =  THIS(); NEXT();
  1959.       value = (value << 8) | THIS(); NEXT();
  1960.       value = (value << 8) | THIS(); NEXT();
  1961.       *tos ++ = value;
  1962.       break;
  1963.     case 0x82:    
  1964.       NEXT();
  1965.       value =  THIS(); NEXT();
  1966.       value = (value << 8) | THIS(); NEXT();
  1967.       *tos ++ = value;
  1968.       break;
  1969.     case 0x81:
  1970.       NEXT();
  1971.       value =  THIS(); NEXT();
  1972.       *tos ++ = value;
  1973.       break;
  1974.       case 0x80:
  1975.       NEXT();
  1976.       *tos ++ = 0;
  1977.       break;
  1978.     default:
  1979.       if (THIS() >0x84) {
  1980.     /* Not a number, just bug out with the answer */
  1981.     write_int(*(--tos));
  1982.     return;
  1983.       }
  1984.       *tos++ = THIS();
  1985. NEXT();
  1986.       value = 0;
  1987.       break;
  1988.     case 0xa5:
  1989.       /* PLUS anything */
  1990.     {
  1991.       int value = *(--tos);
  1992.       value += *(--tos);
  1993.       *tos++ = value;
  1994.       NEXT();
  1995.     }
  1996.       break;
  1997.     case VAR('R') :
  1998.     {
  1999.       int section_number ;
  2000.       ieee_data_type *ieee;
  2001.       asection *s;
  2002.       NEXT();
  2003.       section_number = THIS();
  2004.     
  2005.       NEXT();
  2006.       ieee= ieee_data(input_bfd);
  2007.       s =     ieee->section_table[section_number];
  2008.       if (s->output_section) {
  2009.         value = s->output_section->vma ;
  2010.       } else { value = 0; }
  2011.       value += s->output_offset;
  2012.       *tos++ = value;
  2013.       value = 0;
  2014.     }
  2015.       break;
  2016.     case 0x90:
  2017.     {    
  2018.       NEXT();
  2019.       write_int(*(--tos));
  2020.       OUT(0x90);
  2021.       return;
  2022.  
  2023.     }
  2024.     }
  2025.   }
  2026.  
  2027. }
  2028.  
  2029. /* Drop the int in the buffer, and copy a null into the gap, which we
  2030.    will overwrite later */
  2031.  
  2032. struct output_buffer_struct {
  2033. unsigned  char *ptrp;
  2034.   int buffer;
  2035. } ;
  2036.  
  2037. static void
  2038. DEFUN(fill_int,(buf),
  2039.       struct output_buffer_struct *buf)
  2040. {
  2041.   if (buf->buffer == output_buffer) {
  2042.     /* Still a chance to output the size */
  2043.     int value = output_ptr - buf->ptrp + 3;
  2044.     buf->ptrp[0] =  value >> 24;
  2045.     buf->ptrp[1] =  value >> 16;
  2046.     buf->ptrp[2] =  value >> 8;
  2047.     buf->ptrp[3] =  value >> 0;
  2048.   }
  2049.  
  2050. }
  2051. static void
  2052. DEFUN(drop_int,(buf),
  2053.       struct output_buffer_struct *buf)
  2054. {
  2055.   int type = THIS();
  2056.   int ch;
  2057.   if (type <= 0x84) {
  2058.     NEXT();
  2059.     switch(type) {
  2060.     case 0x84: ch = THIS(); NEXT();
  2061.     case 0x83: ch = THIS(); NEXT();
  2062.     case 0x82: ch = THIS(); NEXT();
  2063.     case 0x81: ch = THIS(); NEXT();
  2064.     case 0x80: break;
  2065.     }
  2066.   }
  2067.   OUT(0x84);
  2068.   buf->ptrp = output_ptr;
  2069.   buf->buffer  = output_buffer;
  2070.   OUT(0);OUT(0);OUT(0);OUT(0);
  2071. }
  2072.  
  2073. static void copy_int()
  2074. {
  2075.   int type = THIS();
  2076.   int ch;
  2077.   if (type <= 0x84) {
  2078.     OUT(type);
  2079.     NEXT();
  2080.     switch(type) {
  2081.     case 0x84: ch = THIS(); NEXT(); OUT(ch);
  2082.     case 0x83: ch = THIS(); NEXT(); OUT(ch);
  2083.     case 0x82: ch = THIS(); NEXT(); OUT(ch);
  2084.     case 0x81: ch = THIS(); NEXT(); OUT(ch);
  2085.     case 0x80: break;
  2086.     }
  2087.   }
  2088. }
  2089.  
  2090. #define ID copy_id()
  2091. #define INT copy_int()
  2092. #define EXP copy_expression()
  2093. static void copy_till_end();
  2094. #define INTn(q) copy_int()
  2095. #define EXPn(q) copy_expression()
  2096. static void f1_record()
  2097. {
  2098.   int ch;
  2099.   /* ATN record */
  2100.   NEXT();
  2101.   ch = THIS();
  2102.   switch (ch)
  2103.       {
  2104.       default:
  2105.     OUT(0xf1); OUT(ch);
  2106.     break;
  2107.       case 0xc9:
  2108.     NEXT();
  2109.     OUT(0xf1); OUT(0xc9);
  2110.     INT; INT; ch = THIS(); 
  2111.     switch (ch) 
  2112.         {
  2113.         case 0x16: NEXT();break;
  2114.         case 0x01: NEXT();break;
  2115.         case 0x00: NEXT(); INT; break;
  2116.         case 0x03: NEXT(); INT; break;
  2117.         case 0x13: EXPn(instruction address); break;
  2118.         default:
  2119.           break;
  2120.         }
  2121.     break;
  2122.       case 0xd8:
  2123.     /* EXternal ref */
  2124.     NEXT();    
  2125.     OUT(0xf1); OUT(0xd8);
  2126.     EXP ; EXP; EXP; EXP;
  2127.     break;
  2128.       case 0xce:
  2129.     NEXT();
  2130.     OUT(0xf1);OUT(0xce); INT; INT; ch = THIS(); INT;
  2131.     switch (ch) {
  2132.     case 0x01:
  2133.       INT; INT; break;
  2134.     case 0x02:
  2135.       INT; break;
  2136.     case 0x04:
  2137.       EXPn(external function); break;
  2138.     case 0x05:
  2139.       break;
  2140.     case 0x07: INTn(line number); INT;
  2141.     case 0x08: break;
  2142.     case 0x0a: INTn(locked register); INT; break;
  2143.     case 0x3f: copy_till_end(); break;
  2144.     case 0x3e: copy_till_end(); break;
  2145.     case 0x40: copy_till_end(); break;
  2146.     case 0x41: ID; break;
  2147.     }
  2148.       }
  2149.  
  2150. }
  2151. static void f0_record()
  2152. {
  2153.   /* Attribute record */
  2154.   NEXT();
  2155.   OUT(0xf0);
  2156.   INTn(Symbol name );
  2157.   ID;
  2158. }
  2159. static void copy_till_end()
  2160. {
  2161.   int  ch = THIS();
  2162.   while (1) {
  2163.     while (ch <= 0x80) 
  2164.     {
  2165.       OUT(ch);
  2166.       NEXT();
  2167.       ch = THIS();
  2168.     }
  2169.     switch (ch) {
  2170.     case 0x84:
  2171.       OUT(THIS());
  2172.       NEXT();
  2173.     case 0x83:
  2174.       OUT(THIS());
  2175.       NEXT();
  2176.     case 0x82:
  2177.       OUT(THIS());
  2178.       NEXT();
  2179.     case 0x81:
  2180.       OUT(THIS());
  2181.       NEXT();
  2182.       OUT(THIS());
  2183.       NEXT();
  2184.  
  2185.       ch = THIS();
  2186.       break;
  2187.     default:
  2188.       return;
  2189.     }
  2190.   }    
  2191.  
  2192. }
  2193.  
  2194. static void f2_record()
  2195. {
  2196.   NEXT();
  2197.   OUT(0xf2);
  2198.   INT ;
  2199.   NEXT();
  2200.   OUT(0xce);
  2201.   INT ;
  2202.   copy_till_end();
  2203. }
  2204.  
  2205.  
  2206. static void block();
  2207. static void f8_record()
  2208. {
  2209.   int ch;
  2210.   NEXT();
  2211.   ch = THIS();
  2212.   switch (ch) 
  2213.       {
  2214.       case 0x01:
  2215.       case 0x02:
  2216.       case 0x03:
  2217.     /* Unique typedefs for module */
  2218.     /* GLobal typedefs  */
  2219.     /* High level module scope beginning */
  2220.       {
  2221.         struct output_buffer_struct ob;
  2222.         NEXT();
  2223.         OUT(0xf8); OUT(ch);
  2224.         drop_int(&ob); ID ;
  2225.  
  2226.         block();
  2227.  
  2228.         NEXT();
  2229.         fill_int(&ob);
  2230.         OUT(0xf9);
  2231.       }
  2232.     break;
  2233.       case 0x04:    
  2234.     /* Global function */
  2235.       {
  2236.         struct output_buffer_struct ob;
  2237.         NEXT();
  2238.         OUT(0xf8); OUT(0x04);
  2239.         drop_int(&ob); ID ; INTn(stack size); INTn(ret val);
  2240.         EXPn(offset); 
  2241.  
  2242.         block();
  2243.  
  2244.         NEXT();
  2245.         OUT(0xf9);    
  2246.         EXPn(size of block);
  2247.         fill_int(&ob);
  2248.       }
  2249.     break;
  2250.  
  2251.       case 0x05:
  2252.     /* File name for source line numbers */
  2253.       {
  2254.         struct output_buffer_struct ob;
  2255.         NEXT();
  2256.         OUT(0xf8); OUT(0x05);
  2257.         drop_int(&ob);
  2258.         ID; INTn(year); INTn(month); INTn(day);
  2259.         INTn(hour); INTn(monute); INTn(second);
  2260.         block();
  2261.         NEXT();
  2262.         OUT(0xf9);
  2263.         fill_int(&ob);
  2264.       }
  2265.     break;
  2266.     
  2267.       case 0x06:
  2268.     /* Local function */
  2269.       { struct output_buffer_struct ob;
  2270.         NEXT(); OUT(0xf8); OUT(0x06);
  2271.         drop_int(&ob);
  2272.         ID; INTn(stack size); INTn(type return);
  2273.         EXPn(offset);
  2274.         block();
  2275.         NEXT();
  2276.         OUT(0xf9);
  2277.         EXPn(size);
  2278.         fill_int(&ob);
  2279.       }
  2280.     break;
  2281.     
  2282.       case 0x0a:
  2283.     /* Assembler module scope beginning -*/
  2284.       { struct output_buffer_struct ob;
  2285.  
  2286.         NEXT();
  2287.         OUT(0xf8); OUT(0x0a); 
  2288.         drop_int(&ob);
  2289.           ID; ID; INT; ID; INT; INT; INT; INT; INT; INT;
  2290.  
  2291.         block();    
  2292.  
  2293.         NEXT();
  2294.         OUT(0xf9);
  2295.         fill_int(&ob);
  2296.       }
  2297.     break;
  2298.       case 0x0b:
  2299.       {
  2300.         struct output_buffer_struct ob;
  2301.         NEXT();
  2302.         OUT(0xf8); OUT(0x0b); 
  2303.         drop_int(&ob); ID ; INT; INTn(section index); EXPn(offset); INTn(stuff);
  2304.  
  2305.         block();
  2306.  
  2307.         OUT(0xf9);
  2308.         NEXT();      
  2309.         EXPn(Size in Maus);
  2310.         fill_int(&ob);
  2311.       }
  2312.     break;
  2313.       }
  2314. }
  2315.  
  2316. static void e2_record()
  2317. {
  2318.   OUT(0xe2);
  2319.   NEXT();
  2320.   OUT(0xce);
  2321.   NEXT();
  2322.   INT;
  2323.   EXP;
  2324. }
  2325.  
  2326. static void DEFUN_VOID(block)
  2327. {
  2328.   int ch ;
  2329.   while (1) {
  2330.     ch = THIS();
  2331.     switch (ch) {
  2332.     case 0xe1:
  2333.     case 0xe5:
  2334.       return;
  2335.     case 0xf9:
  2336.       return;
  2337.     case 0xf0:
  2338.       f0_record();
  2339.       break;
  2340.     case 0xf1:
  2341.       f1_record();    
  2342.       break;
  2343.     case 0xf2:
  2344.       f2_record();
  2345.       break;
  2346.     case 0xf8:
  2347.       f8_record();
  2348.       break;
  2349.     case 0xe2:
  2350.       e2_record();
  2351.       break;
  2352.  
  2353.     }  
  2354.   }
  2355. }
  2356.   
  2357.  
  2358.  
  2359. /* relocate_debug, 
  2360.    moves all the debug information from the source bfd to the output
  2361.    bfd, and relocates any expressions it finds
  2362. */
  2363.  
  2364. static void
  2365. DEFUN(relocate_debug,(output, input),
  2366.       bfd *output AND
  2367.       bfd *input)
  2368. {
  2369. #define IBS 400
  2370. #define OBS 400
  2371.   unsigned char input_buffer[IBS];
  2372.  
  2373.   input_ptr_start = input_ptr = input_buffer;
  2374.   input_ptr_end = input_buffer + IBS;
  2375.   input_bfd = input;
  2376.   bfd_read((PTR)input_ptr_start, 1, IBS, input);
  2377.   block();
  2378. }
  2379. /* 
  2380.   During linking, we we told about the bfds which made up our
  2381.   contents, we have a list of them. They will still be open, so go to
  2382.   the debug info in each, and copy it out, relocating it as we go.
  2383. */
  2384.  
  2385. static void 
  2386. DEFUN(ieee_write_debug_part, (abfd),
  2387.       bfd *abfd)
  2388. {
  2389.   ieee_data_type *ieee = ieee_data(abfd);
  2390.   bfd_chain_type *chain = ieee->chain_root;
  2391.   unsigned char output_buffer[OBS];
  2392.   boolean some_debug = false;
  2393.   file_ptr here = bfd_tell(abfd);
  2394.  
  2395.   output_ptr_start = output_ptr = output_buffer ;
  2396.   output_ptr_end = output_buffer + OBS;
  2397.   output_ptr = output_buffer;
  2398.   output_bfd = abfd;
  2399.  
  2400.   if (chain == (bfd_chain_type *)NULL) {
  2401.     /* There is no debug info, so we'll fake some up */
  2402.     CONST static char fake[] = {
  2403.       0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3,
  2404.       '1','.','1',0x82, 1991>>8, 1991 & 0xff, 9, 20, 11, 07,50 };
  2405.     ieee->w.r.debug_information_part = 0;
  2406.  
  2407. #if 0
  2408. here;
  2409.  
  2410.  
  2411. /*    bfd_write(fake, 1, sizeof(fake), abfd);*/
  2412.     /* Now write a header for each section */
  2413.       {
  2414.     int i = 0;
  2415.     asection *s = abfd->sections;
  2416.     while (s) {
  2417.       ieee_write_byte(abfd, 0xf8);    
  2418.       ieee_write_byte(abfd, 0x0b);
  2419.       ieee_write_byte(abfd, 0);
  2420.       ieee_write_byte(abfd, 0);
  2421.       ieee_write_byte(abfd, 1);
  2422.       ieee_write_byte(abfd, i + IEEE_SECTION_NUMBER_BASE);
  2423.       ieee_write_expression(abfd, 0, s, 0, 0, 0);
  2424.       ieee_write_byte(abfd,0);
  2425.       ieee_write_byte(abfd, 0xf9);
  2426.       ieee_write_expression(abfd, s->size, 0, 0, 0, 0);    
  2427.       s = s->next;
  2428.       i++;
  2429.     }    
  2430.     /* Close the scope */
  2431.     ieee_write_byte(abfd, 0xf9);
  2432.       }
  2433. #endif
  2434.   }
  2435.   else{
  2436.     while (chain != (bfd_chain_type *)NULL) {
  2437.       bfd *entry = chain->this;
  2438.       ieee_data_type *entry_ieee = ieee_data(entry);
  2439.       if (entry_ieee->w.r.debug_information_part) {
  2440.     bfd_seek(entry, entry_ieee->w.r.debug_information_part, SEEK_SET);
  2441.     relocate_debug(abfd, entry);
  2442.       }
  2443.  
  2444.       chain = chain->next;
  2445.     }
  2446.     if (some_debug) {
  2447.       ieee->w.r.debug_information_part = here;
  2448.     }
  2449.     else {
  2450.       ieee->w.r.debug_information_part = 0;
  2451.     }
  2452.   }
  2453.   flush();
  2454.  
  2455. }  
  2456. /* write the data in an ieee way */
  2457. static void
  2458. DEFUN(ieee_write_data_part,(abfd),
  2459.       bfd *abfd)
  2460. {
  2461.   asection *s;
  2462.   ieee_data_type *ieee = ieee_data(abfd);
  2463.   ieee->w.r.data_part = bfd_tell(abfd);
  2464.   for (s = abfd->sections; s != (asection *)NULL; s = s->next) 
  2465.       {
  2466.     /* Sort the reloc records so we can insert them in the correct
  2467.        places */
  2468.     if (s->reloc_count != 0) 
  2469.         {
  2470.          do_with_relocs(abfd, s);
  2471.         }
  2472.     else
  2473.         {
  2474.           do_without_relocs(abfd, s);
  2475.         }
  2476.       }
  2477. }
  2478.  
  2479.  
  2480.  
  2481. static void
  2482. DEFUN(init_for_output,(abfd),
  2483.       bfd *abfd)
  2484. {
  2485.   asection *s; 
  2486.   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
  2487.     if (s->size != 0) {
  2488.       ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->size));
  2489.     }
  2490.   }
  2491. }
  2492.  
  2493. /** exec and core file sections */
  2494.  
  2495. /* set section contents is complicated with IEEE since the format is 
  2496. * not a byte image, but a record stream.
  2497. */
  2498. boolean
  2499. DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count),
  2500.       bfd *abfd AND
  2501.       sec_ptr section AND
  2502.       PTR location AND
  2503.       file_ptr offset AND
  2504.       bfd_size_type count)
  2505. {
  2506.   if (ieee_per_section(section)->data == (bfd_byte *)NULL) {
  2507.     init_for_output(abfd);
  2508.   }
  2509.   (void) memcpy((PTR)(ieee_per_section(section)->data + offset),
  2510.         (PTR)location,
  2511.         (unsigned int)count);
  2512.   return true;
  2513. }
  2514.  
  2515. /*
  2516. write the external symbols of a file, IEEE considers two sorts of
  2517. external symbols, public, and referenced. It uses to internal forms
  2518. to index them as well. When we write them out we turn their symbol
  2519. values into indexes from the right base.
  2520. */
  2521. static void
  2522. DEFUN(ieee_write_external_part,(abfd),
  2523.       bfd *abfd)
  2524. {
  2525.   asymbol **q;
  2526.   ieee_data_type *ieee = ieee_data(abfd);
  2527.  
  2528.   unsigned int reference_index = IEEE_REFERENCE_BASE;
  2529.   unsigned int public_index = IEEE_PUBLIC_BASE+2;
  2530.   file_ptr here = bfd_tell(abfd);
  2531.   boolean hadone = false;
  2532.   if (abfd->outsymbols != (asymbol **)NULL) {
  2533.  
  2534.     for (q = abfd->outsymbols; *q  != (asymbol *)NULL; q++) {
  2535.       asymbol *p = *q;
  2536.       hadone = true;
  2537.       if (p->flags & BSF_UNDEFINED) {
  2538.     /* This must be a symbol reference .. */
  2539.     ieee_write_byte(abfd, ieee_external_reference_enum);
  2540.     ieee_write_int(abfd, reference_index);
  2541.     ieee_write_id(abfd, p->name);
  2542.     p->value = reference_index;
  2543.     reference_index++;
  2544.       }
  2545.       else if(p->flags & BSF_FORT_COMM) {
  2546.     /* This is a weak reference */
  2547.     ieee_write_byte(abfd, ieee_external_reference_enum);
  2548.     ieee_write_int(abfd, reference_index);
  2549.     ieee_write_id(abfd, p->name);
  2550.     ieee_write_byte(abfd, ieee_weak_external_reference_enum);
  2551.     ieee_write_int(abfd, reference_index);
  2552.     ieee_write_int(abfd, p->value);
  2553.     ieee_write_int(abfd, BFD_FORT_COMM_DEFAULT_VALUE);
  2554.     p->value = reference_index;
  2555.     reference_index++;
  2556.       }
  2557.       else if(p->flags & BSF_GLOBAL) {
  2558.     /* This must be a symbol definition */
  2559.  
  2560.  
  2561.     ieee_write_byte(abfd, ieee_external_symbol_enum);
  2562.     ieee_write_int(abfd, public_index );
  2563.     ieee_write_id(abfd, p->name);
  2564.  
  2565.     ieee_write_twobyte(abfd, ieee_attribute_record_enum);
  2566.     ieee_write_int(abfd, public_index );
  2567.     ieee_write_byte(abfd, 15);     /* instruction address */
  2568.     ieee_write_byte(abfd, 19);    /* static symbol */
  2569.     ieee_write_byte(abfd, 1);    /* one of them */
  2570.  
  2571.  
  2572.     /* Write out the value */
  2573.     ieee_write_2bytes(abfd, ieee_value_record_enum);
  2574.     ieee_write_int(abfd, public_index);
  2575.     if (p->section != (asection *)NULL)
  2576.         {
  2577.           if (abfd->flags & EXEC_P) 
  2578.           {
  2579.             /* If fully linked, then output all symbols
  2580.                relocated */
  2581.             ieee_write_int(abfd,
  2582.                    p->value + p->section->output_offset+ p->section->output_section->vma);
  2583.  
  2584.           }
  2585.           else { 
  2586.         ieee_write_expression(abfd,
  2587.                       p->value + p->section->output_offset,
  2588.                       p->section->output_section,
  2589.                       (asymbol *)NULL, false, 0);
  2590.           }
  2591.         }
  2592.     else
  2593.         {
  2594.           ieee_write_expression(abfd,
  2595.                     p->value,
  2596.                     (asection *)NULL,
  2597.                     (asymbol *)NULL, false, 0);
  2598.         }
  2599.     p->value = public_index;
  2600.     public_index++;
  2601.       }
  2602.       else {
  2603.     /* This can happen - when there are gaps in the symbols read */
  2604.     /* from an input ieee file */
  2605.       }
  2606.     }
  2607.   }
  2608.   if (hadone)
  2609.     ieee->w.r.external_part = here;
  2610.  
  2611. }
  2612.  
  2613.  
  2614. CONST static char exten[] = 
  2615.   {
  2616.     0xf0, 0x20, 0x00,                    
  2617.     0xf1, 0xce, 0x20, 0x00, 37, 3, 3,    /* Set version 3 rev 3       */
  2618.     0xf1, 0xce, 0x20, 0x00, 39, 2,    /* keep symbol in  original case */
  2619.     0xf1, 0xce, 0x20, 0x00, 38        /* set object type relocateable to x */
  2620.   };
  2621.  
  2622. CONST static char environ[] =
  2623.   {
  2624.     0xf0, 0x21, 0x00,
  2625.  
  2626. /*    0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
  2627.     0x19, 0x2c, 
  2628. */
  2629.     0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
  2630.  
  2631.     0xf1, 0xce, 0x21, 0, 53, 0x03,    /* host unix */
  2632. /*    0xf1, 0xce, 0x21, 0, 54, 2,1,1    tool & version # */
  2633.   };
  2634.  
  2635. static
  2636. void 
  2637. DEFUN(ieee_write_me_part,(abfd),
  2638.       bfd *abfd)
  2639. {
  2640.   ieee_data_type *ieee= ieee_data(abfd);
  2641.   ieee->w.r.trailer_part = bfd_tell(abfd);
  2642.   if (abfd->start_address) {
  2643.     ieee->w.r.me_record = bfd_tell(abfd);
  2644.     ieee_write_2bytes(abfd, ieee_value_starting_address_enum);
  2645.     ieee_write_byte(abfd, ieee_function_either_open_b_enum);
  2646.     ieee_write_int(abfd, abfd->start_address);
  2647.     ieee_write_byte(abfd, ieee_function_either_close_b_enum);
  2648.   }
  2649.   else {
  2650.     ieee->w.r.me_record = bfd_tell(abfd);
  2651.   }
  2652.   ieee_write_byte(abfd, ieee_module_end_enum);
  2653.  
  2654. }
  2655. boolean
  2656. DEFUN(ieee_write_object_contents,(abfd),
  2657.       bfd *abfd)
  2658. {
  2659.   ieee_data_type *ieee = ieee_data(abfd);
  2660.   unsigned int i;
  2661.   file_ptr   old;
  2662.   /* Fast forward over the header area */
  2663.   bfd_seek(abfd, 0, 0);
  2664.   ieee_write_byte(abfd, ieee_module_beginning_enum);
  2665.  
  2666.   ieee_write_id(abfd, bfd_printable_name(abfd));
  2667.   ieee_write_id(abfd, abfd->filename);
  2668.  
  2669.  
  2670.  
  2671.  
  2672.   /* Fast forward over the variable bits */    
  2673.  
  2674.  
  2675.  
  2676.   ieee_write_byte(abfd, ieee_address_descriptor_enum);
  2677.  
  2678.   /* Bits per MAU */
  2679.   ieee_write_byte(abfd, bfd_arch_bits_per_byte(abfd));
  2680.   /* MAU's per address */
  2681.   ieee_write_byte(abfd, bfd_arch_bits_per_address(abfd)  /
  2682.           bfd_arch_bits_per_byte(abfd));
  2683.  
  2684.  
  2685.   old = bfd_tell(abfd);
  2686.   bfd_seek(abfd, 8 * N_W_VARIABLES, 1);
  2687.  
  2688.  
  2689.   ieee->w.r.extension_record = bfd_tell(abfd);
  2690.   bfd_write(exten, 1, sizeof(exten), abfd);
  2691.   if (abfd->flags & EXEC_P) 
  2692.     ieee_write_byte(abfd, 0x1); /* Absolute */
  2693.   else 
  2694.     ieee_write_byte(abfd, 0x2); /* Relocateable */    
  2695.   
  2696.   ieee->w.r.environmental_record = bfd_tell(abfd);
  2697.   bfd_write(environ, 1, sizeof(environ), abfd);
  2698.   output_bfd = abfd;
  2699.   flush();
  2700.  
  2701.   ieee_write_section_part(abfd);
  2702.   /*
  2703.     First write the symbols, this changes their values into table 
  2704.     indeces so we cant use it after this point
  2705.     */
  2706.   ieee_write_external_part(abfd);     
  2707.   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
  2708.  
  2709.  
  2710.   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
  2711.  
  2712.  
  2713.   /*
  2714.     Write any debugs we have been told about 
  2715.     */
  2716.   ieee_write_debug_part(abfd);
  2717.  
  2718.   /* 
  2719.     Can only write the data once the symbols have been written since
  2720.     the data contains relocation information which points to the
  2721.     symbols 
  2722.     */
  2723.   ieee_write_data_part(abfd);     
  2724.  
  2725.  
  2726.   /*
  2727.     At the end we put the end !
  2728.     */
  2729.   ieee_write_me_part(abfd);
  2730.  
  2731.  
  2732.   /* Generate the header */
  2733.   bfd_seek(abfd, old, false);
  2734.  
  2735.   for (i= 0; i < N_W_VARIABLES; i++) {
  2736.     ieee_write_2bytes(abfd,ieee_assign_value_to_variable_enum);
  2737.     ieee_write_byte(abfd, i);
  2738.     ieee_write_int5_out(abfd, ieee->w.offset[i]);
  2739.   }
  2740.   return true;
  2741. }
  2742.  
  2743.  
  2744.  
  2745.  
  2746. /* Native-level interface to symbols. */
  2747.  
  2748. /* We read the symbols into a buffer, which is discarded when this
  2749. function exits.  We read the strings into a buffer large enough to
  2750. hold them all plus all the cached symbol entries. */
  2751.  
  2752. asymbol *
  2753. DEFUN(ieee_make_empty_symbol,(abfd),
  2754.       bfd *abfd)
  2755. {
  2756.  
  2757.   ieee_symbol_type  *new =
  2758.     (ieee_symbol_type *)zalloc (sizeof (ieee_symbol_type));
  2759.   new->symbol.the_bfd = abfd;
  2760.   return &new->symbol;
  2761.  
  2762. }
  2763.  
  2764. static bfd *
  2765. DEFUN(ieee_openr_next_archived_file,(arch, prev),
  2766.       bfd *arch AND
  2767.       bfd *prev)
  2768. {
  2769.   ieee_ar_data_type *ar = ieee_ar_data(arch);
  2770.   /* take the next one from the arch state, or reset */
  2771.   if (prev == (bfd *)NULL) {
  2772.     /* Reset the index - the first two entries are bogus*/
  2773.     ar->element_index = 2;
  2774.   }
  2775.   while (true) {  
  2776.     ieee_ar_obstack_type *p = ar->elements + ar->element_index;
  2777.     ar->element_index++;
  2778.     if (ar->element_index <= ar->element_count) {
  2779.       if (p->file_offset != (file_ptr)0) {
  2780.     if (p->abfd == (bfd *)NULL) {
  2781.       p->abfd = _bfd_create_empty_archive_element_shell(arch);
  2782.       p->abfd->origin = p->file_offset;
  2783.     }
  2784.     return p->abfd;
  2785.       }
  2786.     }
  2787.     else {
  2788.       bfd_error = no_more_archived_files;
  2789.       return (bfd *)NULL;
  2790.     }
  2791.  
  2792.   }
  2793. }
  2794.  
  2795. static boolean
  2796. ieee_find_nearest_line(abfd,
  2797.              section,
  2798.              symbols,
  2799.              offset,
  2800.              filename_ptr,
  2801.              functionname_ptr,
  2802.              line_ptr)
  2803. bfd *abfd;
  2804. asection *section;
  2805. asymbol **symbols;
  2806. bfd_vma offset;
  2807. char **filename_ptr;
  2808. char **functionname_ptr;
  2809. int *line_ptr;
  2810. {
  2811.   return false;
  2812. }
  2813.  
  2814.  
  2815. static int
  2816. ieee_generic_stat_arch_elt(abfd, buf)
  2817. bfd *abfd;
  2818. struct stat *buf;
  2819. {
  2820.   ieee_ar_data_type *ar = ieee_ar_data(abfd);
  2821.   if (ar == (ieee_ar_data_type *)NULL) {
  2822.     bfd_error = invalid_operation;
  2823.     return -1;
  2824.   }
  2825.   else {
  2826.     buf->st_size = 0x1;
  2827.     buf->st_mode = 0666;
  2828.   return 0;
  2829.   }
  2830. }
  2831. static int 
  2832. DEFUN(ieee_sizeof_headers,(abfd, x),
  2833.       bfd *abfd AND
  2834.       boolean x)
  2835. {
  2836.   return 0;
  2837. }
  2838.  
  2839.  
  2840.  
  2841. static void 
  2842. DEFUN(ieee_bfd_debug_info_start,(abfd), 
  2843.       bfd *abfd)
  2844.   {
  2845.  
  2846.   }
  2847.  
  2848. static void 
  2849. DEFUN(ieee_bfd_debug_info_end,(abfd), 
  2850.       bfd *abfd)
  2851.   {
  2852.  
  2853.   }
  2854.  
  2855.  
  2856. /* Add this section to the list of sections we have debug info for, to
  2857.    be ready to output it at close time 
  2858.    */
  2859. static void 
  2860. DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section), 
  2861.       bfd *abfd AND
  2862.       asection *section)
  2863. {
  2864.   ieee_data_type *ieee = ieee_data(section->owner);
  2865.   ieee_data_type *output_ieee = ieee_data(abfd);
  2866.   /* can only accumulate data from other ieee bfds */
  2867.   if (section->owner->xvec != abfd->xvec)
  2868.     return;
  2869.   /* Only bother once per bfd */
  2870.   if (ieee->done_debug == true) 
  2871.     return;
  2872.   ieee->done_debug = true;
  2873.  
  2874.   /* Don't bother if there is no debug info */
  2875.   if (ieee->w.r.debug_information_part == 0)
  2876.     return;
  2877.  
  2878.  
  2879.   /* Add to chain */
  2880.     {
  2881.       bfd_chain_type *n = (bfd_chain_type *) bfd_alloc(abfd, sizeof(bfd_chain_type));
  2882.       n->this = section->owner;
  2883.       n->next = (bfd_chain_type *)NULL;
  2884.     
  2885.       if (output_ieee->chain_head) {
  2886.     output_ieee->chain_head->next = n;
  2887.       }
  2888.       else {
  2889.     output_ieee->chain_root = n;
  2890.  
  2891.       }
  2892.     output_ieee->chain_head = n; 
  2893.     }
  2894. }
  2895.  
  2896.  
  2897.  
  2898.  
  2899.  
  2900.  
  2901. #define FOO PROTO
  2902. #define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
  2903. #define ieee_core_file_failing_signal (int (*)())bfd_0
  2904. #define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false
  2905. #define ieee_slurp_armap bfd_true
  2906. #define ieee_slurp_extended_name_table bfd_true
  2907. #define ieee_truncate_arname (void (*)())bfd_nullvoidptr
  2908. #define ieee_write_armap  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
  2909. #define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
  2910. #define    ieee_close_and_cleanup        bfd_generic_close_and_cleanup
  2911. #define ieee_set_arch_mach bfd_default_set_arch_mach
  2912.  
  2913. /*SUPPRESS 460 */
  2914. bfd_target ieee_vec =
  2915. {
  2916.   "ieee",            /* name */
  2917.   bfd_target_ieee_flavour,
  2918.   true,                /* target byte order */
  2919.   true,                /* target headers byte order */
  2920.   (HAS_RELOC | EXEC_P |        /* object flags */
  2921.    HAS_LINENO | HAS_DEBUG |
  2922.    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
  2923.   (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
  2924.    |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  2925.   ' ',                /* ar_pad_char */
  2926.   16,                /* ar_max_namelen */
  2927.     1,                /* minimum alignment */
  2928. _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
  2929. _do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
  2930.  
  2931.   { _bfd_dummy_target,
  2932.      ieee_object_p,        /* bfd_check_format */
  2933.      ieee_archive_p,
  2934.     _bfd_dummy_target,
  2935.      },
  2936.   {
  2937.     bfd_false,
  2938.     ieee_mkobject, 
  2939.     _bfd_generic_mkarchive,
  2940.     bfd_false
  2941.     },
  2942.   {
  2943.     bfd_false,
  2944.     ieee_write_object_contents,
  2945.     _bfd_write_archive_contents,
  2946.     bfd_false,
  2947.   },
  2948.   JUMP_TABLE(ieee)
  2949. };
  2950.